diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml new file mode 100644 index 00000000..490e0370 --- /dev/null +++ b/.github/workflows/maven.yml @@ -0,0 +1,75 @@ +name: Maven CI + +on: + push: + branches: ["main", "feat/**", "fix/**"] + paths-ignore: + - "**/*.md" + - "doc/**" + pull_request: + branches: ["main", "feat/**", "fix/**"] + paths-ignore: + - "**/*.md" + - "doc/**" + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + name: Build and test (Java 21 / Spark 3.5) + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Java 21 + uses: actions/setup-java@v4 + with: + distribution: temurin + java-version: "21" + cache: maven + + - name: Install libmeos runtime dependencies + run: | + sudo apt-get update -qq + sudo apt-get install -y libjson-c5 libgeos-c1t64 libproj25 libgsl27 + + - name: Set up libmeos.so and LD_LIBRARY_PATH + run: | + mkdir -p /tmp/libmeos + cp "$GITHUB_WORKSPACE/lib/libmeos.so" /tmp/libmeos/libmeos.so + echo "LD_LIBRARY_PATH=/tmp/libmeos" >> "$GITHUB_ENV" + + - name: Install JMEOS 1.4 to local Maven repository + run: | + mvn install:install-file \ + -Dfile=libs/JMEOS-1.4.jar \ + -DgroupId=org.jmeos \ + -DartifactId=jmeos \ + -Dversion=1.4 \ + -Dpackaging=jar \ + -q + + - name: License header check + run: bash tools/scripts/check_license.sh + + - name: Compile + run: mvn -B compile + + - name: Unit tests + run: mvn -B test + + - name: Portable bare-name parity gate (RFC #920 — 29/29, 0 unbacked) + run: python3 scripts/portable_parity.py --mspark . + + - name: Package (fat jar) + run: mvn -B package -DskipTests + + - name: Upload fat jar + uses: actions/upload-artifact@v4 + with: + name: mobilityspark-spark.jar + path: target/*-spark.jar diff --git a/.gitignore b/.gitignore index fc368f31..0fbf0af9 100644 --- a/.gitignore +++ b/.gitignore @@ -3,14 +3,21 @@ .project .settings/ -# Intellij +# IntelliJ IDEA .idea/ *.iml *.iws +*.ipr -# Mac +# macOS .DS_Store +**/.DS_Store # Maven log/ target/ + +# Large BerlinMOD benchmark data (generated locally — too large for GitHub) +berlinmod/data/trips.csv +dependency-reduced-pom.xml +hs_err_pid*.log diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..b9640c8f --- /dev/null +++ b/LICENSE @@ -0,0 +1,22 @@ +------------------------------------------------------------------------------- +This MobilityDB code is provided under The PostgreSQL License. + +Copyright (c) 2020-2025, Université libre de Bruxelles and MobilityDB +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. diff --git a/berlinmod/README.md b/berlinmod/README.md new file mode 100644 index 00000000..43fd7cfb --- /dev/null +++ b/berlinmod/README.md @@ -0,0 +1,192 @@ +# BerlinMOD Portable SQL — Cross-Platform Verification + +This directory contains BerlinMOD benchmark queries in the **RFC #861 portable +dialect** — using named functions only, no MobilityDB-specific operator symbols. +The same SQL files run unchanged on all three platforms. + +| Platform | Engine | Extension | +|---|---|---| +| [MobilityDB](https://github.com/MobilityDB/MobilityDB) | PostgreSQL | `CREATE EXTENSION mobilitydb` | +| [MobilityDuck](https://github.com/MobilityDB/MobilityDuck) | DuckDB | `LOAD mobilitydb` (community) | +| [MobilitySpark](https://github.com/MobilityDB/MobilitySpark) | Apache Spark | `MobilitySparkSession.create(spark)` | + +--- + +## Schema + +All three platforms use the same schema: + +``` +Vehicles (vehId INT, licence TEXT, type TEXT, model TEXT) +Trips (tripId INT, vehId INT, trip TEXT) -- tgeompoint hex-WKB +QueryLicences (licenceId INT, licence TEXT) +QueryInstants (instantId INT, instant TIMESTAMPTZ) +QueryPoints (pointId INT, geom TEXT) -- geometry WKT, SRID 0 +QueryRegions (regionId INT, geom TEXT) -- polygon WKT, SRID 0 +QueryPeriods (periodId INT, period TEXT) -- tstzspan literal +``` + +**Storage conventions:** +- `tgeompoint` values → hex-WKB STRING (`temporal_as_hexwkb` / `temporal_from_hexwkb`) +- `geometry` / polygon values → WKT STRING, parsed via `geo_from_text` / `ST_GeomFromText` +- `tstzspan` values → literal STRING `"[t1,t2]"`, cast to `tstzspan` by each platform + +Storing temporal/geometry values as portable text keeps the CSV files +human-readable across all platforms without requiring platform-specific binary +encoding. + +--- + +## Queries + +| File | Query | Temporal operations | +|------|-------|---------------------| +| `q01.sql` | Vehicle models for query licences | none (baseline relational join) | +| `q02.sql` | Licence plates of vehicles that ever entered a query region | `eIntersects(tgeompoint, geometry)` | +| `q03.sql` | Position of query-licence vehicles at each query instant | `atTime(tgeompoint, timestamptz)` | +| `q04.sql` | Vehicles that ever passed a query point | `eIntersects(tgeompoint, geometry)` | +| `q05.sql` | Min nearest-approach distance between query-licence pairs | `nearestApproachDistance(tgeompoint, tgeompoint)` | +| `q06.sql` | Truck pairs within 10 m | `eDwithin(tgeompoint, tgeompoint, float)` | +| `q07.sql` | Trip portions of query-licence vehicles during each query period | `atTime(tgeompoint, tstzspan)` | +| `q08.sql` | Trajectory geometry of each trip | `trajectory(tgeompoint)` | +| `q09.sql` | Longest distance driven by any vehicle in each query period | `atTime`, `length` | +| `q10.sql` | When did query-licence vehicles meet others (within 3 m)? | `expandSpace`, `tDwithin`, `whenTrue` | +| `q11.sql` | Vehicles passing a query point at a query instant | `valueAtTimestamp`, `stbox` | +| `q12.sql` | Vehicle pairs at the same query point at the same query instant | `valueAtTimestamp`, `stbox` | +| `q13.sql` | Vehicles that travelled within a query region during a query period | `atTime`, `eIntersects`, `stbox` | +| `q14.sql` | Vehicles inside a query region at a query instant | `valueAtTimestamp`, `ST_Contains`, `stbox` | +| `q15.sql` | Vehicles that passed a query point during a query period | `atTime`, `eIntersects`, `stbox` | +| `q16.sql` | Query-licence vehicle pairs in same region+period but always disjoint | `atTime`, `eIntersects`, `aDisjoint` | +| `q17.sql` | Query points visited by the most distinct vehicles | `eIntersects` | +| `qrt.sql` | Binary roundtrip — all trips serialised as hex-WKB | `asHexWKB(tgeompoint)` | + +`atTime` is polymorphic: pass a `TIMESTAMPTZ` (Q3) or a `tstzspan` literal (Q7) +and the platform routes to the appropriate MEOS function. + +--- + +## Shared dataset + +`data/` contains CSV files that all three platforms load: + +| File | Description | +|------|-------------| +| `data/vehicles.csv` | 5 vehicles (3 passenger, 2 truck) | +| `data/trips.csv` | 5 trips, each as a tgeompoint hex-WKB string (SRID 0) | +| `data/query_licences.csv` | 2 query licences | +| `data/query_instants.csv` | 1 query instant | +| `data/query_points.csv` | 2 query points (WKT) | +| `data/query_regions.csv` | 1 query polygon region (WKT) | +| `data/query_periods.csv` | 1 query period (tstzspan literal) | + +**Dataset design (SRID 0, planar):** + +``` +trip1 (B-AA 100): (0,0) → (100,0) y = 0 +trip2 (B-BB 200): (0,5) → (100,5) y = 5 +trip3 (B-CC 300): (0,3) → (100,3) y = 3 (truck) +trip4 (B-DD 400): (0,4) → (100,4) y = 4 (truck, 1 unit from trip3) +trip5 (B-EE 500): far away (not near others) + +QueryPoints: POINT(50 0), POINT(50 5) +QueryRegions: POLYGON((40 -1,60 -1,60 6,40 6,40 -1)) covers x=40..60, y=-1..6 +QueryPeriods: [2020-01-01 00:02:00+00, 2020-01-01 00:08:00+00] +All trips active during: 2020-01-01 00:00 – 00:10 UTC +``` + +**Expected results (verified on MobilityDuck/DuckDB with toy dataset):** + +| Query | Result | +|-------|--------| +| Q1 | B-AA 100 → Sedan ; B-CC 300 → Lorry | +| Q2 | B-AA 100, B-BB 200, B-CC 300, B-DD 400 (all 4 non-remote vehicles) | +| Q3 | 2 rows — MEOS hex-WKB of position at 00:05 UTC | +| Q4 | B-AA 100, B-BB 200 | +| Q5 | B-AA 100 ↔ B-CC 300 : 3.0 (nearest approach distance) | +| Q6 | B-CC 300 ↔ B-DD 400 (trucks within 10 m) | +| Q7 | 2 rows — hex-WKB of trip portions during the query period | +| Q8 | 5 rows — WKT trajectory geometry for each trip | +| Q9 | 1 row — vehicle 5 (EE 500) covers max distance (600 units) in the query period | +| Q10 | 4 meetings — B-AA 100 meets vehicle 3; B-CC 300 meets vehicles 1, 2, and 4 | +| Q11 | 2 rows — B-AA 100 at POINT(50 0); B-BB 200 at POINT(50 5) at 00:05 | +| Q12 | 0 rows — no two vehicles at the same point at the same instant | +| Q13 | 4 rows — vehicles AA/BB/CC/DD all traverse the query region in the query period | +| Q14 | 4 rows — same 4 vehicles inside the query region at 00:05 | +| Q15 | 2 rows — B-AA 100 passes POINT(50 0); B-BB 200 passes POINT(50 5) in the period | +| Q16 | 1 row — query-licence pair AA/CC in region during period but always spatially disjoint | +| Q17 | 2 rows — both query points tied at 1 vehicle visit each | +| QRT | 5 rows — MEOS hex-WKB of all 5 trips (binary roundtrip) | + +Expected CSV files for all queries are in `expected/`. + +**Cross-platform portability design:** +- Q3 / Q7 / QRT: use `asHexWKB()` → `temporal_as_hexwkb(ptr, 0)` — byte-for-byte identical +- Q8: uses `trajectory()` → `geo_as_hexewkb(ptr, NULL)` (PostgreSQL COPY, DuckDB COPY, and MobilitySpark UDF all produce the same little-endian WKB hex) +- Q11/Q12/Q15: use `p.geomWKT` (original WKT text from CSV) instead of `ST_AsText(geom)` to avoid `POINT(x y)` vs `POINT (x y)` format divergence between PostGIS and DuckDB spatial +- All other queries: boolean / integer / float / text outputs — identical across platforms + +--- + +## Running on MobilityDB (PostgreSQL) + +```bash +# Create a database and run the comparison: +createdb berlinmod_portability +./berlinmod/run_mbdb.sh berlinmod_portability +``` + +--- + +## Running on MobilityDuck (DuckDB) + +```bash +# Run from the repository root: +./berlinmod/run_mduck.sh [path/to/duckdb] +``` + +--- + +## Running on MobilitySpark (Apache Spark) + +```bash +./berlinmod/run_mspark.sh [spark-submit-binary] +``` + +Or manually: + +```bash +ulimit -c 0 # suppress multi-GB core dumps on native-library crashes +spark-submit \ + --class org.mobilitydb.spark.demo.BerlinMODDemo \ + --master "local[2]" \ + --conf "spark.driver.extraJavaOptions=-Djava.library.path=/usr/local/lib" \ + target/mobilityspark-*-spark.jar \ + berlinmod/data \ + berlinmod/expected +``` + +--- + +## Replacing the synthetic dataset with real BerlinMOD data + +The shared CSV format is produced directly by +[MobilityDB-BerlinMOD](https://github.com/MobilityDB/MobilityDB-BerlinMOD) +via `berlinmod_portability_export()`: + +```sql +-- In a PostgreSQL database with generated BerlinMOD data: +\i BerlinMOD/berlinmod_export.sql +SELECT berlinmod_portability_export('/path/to/output/'); +``` + +This writes `vehicles.csv`, `trips.csv`, `query_licences.csv`, +`query_instants.csv`, `query_points.csv`, `query_regions.csv`, and +`query_periods.csv` in exactly the schema expected by the comparison scripts. + +Replace `data/*.csv` with the generated files and re-run: + +```bash +./berlinmod/run_mbdb.sh berlinmod_portability # MobilityDB +./berlinmod/run_mduck.sh # MobilityDuck +./berlinmod/run_mspark.sh # MobilitySpark +``` diff --git a/berlinmod/bench/.gitignore b/berlinmod/bench/.gitignore new file mode 100644 index 00000000..cb625ea7 --- /dev/null +++ b/berlinmod/bench/.gitignore @@ -0,0 +1,6 @@ +# Machine-specific benchmark results — do not commit +results/*.json +results/report.md + +# DuckDB scratch database +/tmp/berlinmod_bench.duckdb diff --git a/berlinmod/bench/README.md b/berlinmod/bench/README.md new file mode 100644 index 00000000..e103f678 --- /dev/null +++ b/berlinmod/bench/README.md @@ -0,0 +1,150 @@ +# BerlinMOD Cross-Platform Benchmark + +Measures the 18 BerlinMOD portable SQL queries on three platforms — **MobilityDB** +(PostgreSQL), **MobilityDuck** (DuckDB), and **MobilitySpark** (Apache Spark) — +using identical SQL on a shared CSV dataset. + +Queries are defined in [Discussion #861](https://github.com/MobilityDB/MobilityDB/discussions/861). +Share your results on [Discussion #913](https://github.com/MobilityDB/MobilityDB/discussions/913). + +--- + +## Prerequisites + +### All platforms +- Python 3.8+ (for `report.py` and the JSON conversion in timing scripts) +- `osm2pgrouting` (for generating BerlinMOD data): + ```bash + sudo apt-get install osm2pgrouting + ``` + +### MobilityDB +- PostgreSQL with MobilityDB installed +- `psql` on `PATH` + +### MobilityDuck +- `duckdb` CLI (community or local MobilityDuck build) on `PATH` + + The script auto-detects a local MobilityDuck build at `$MOBILITYDUCK_CLI` + or falls back to the system `duckdb`. + +### MobilitySpark +Install once: +```bash +# 1. Maven (builds the fat JAR) +sudo apt-get install maven + +# 2. Apache Spark 3.5.4 (~300 MB) +bash ../../setup/install_spark.sh +source ~/.bashrc # or open a new shell + +# 3. Build the JAR (once, or after code changes) +cd ../.. +mvn package -DskipTests -q +``` + +--- + +## Quick start + +### 1 — Generate the dataset + +```bash +# Generate BerlinMOD CSV data (scale 0.005 → ~100 vehicles, ~10 000 trips, ~15 min) +bash ../../setup/generate_data.sh + +# Larger dataset (scale 0.05 → ~1000 vehicles, ~100 000 trips, ~2–3 h) +bash ../../setup/generate_data.sh --scalefactor 0.05 +``` + +CSV files land in `berlinmod/data/` by default. + +### 2 — Run the benchmark + +```bash +# All three platforms, 3 runs per query, data from berlinmod/data/ +bash bench.sh + +# Skip platforms you haven't installed +bash bench.sh --skip-mspark +bash bench.sh --skip-mbdb --skip-mduck # Spark only + +# Custom data directory, 5 runs, custom output directory +bash bench.sh --data /path/to/data --runs 5 --output /path/to/results +``` + +Results are written to `results/mbdb.json`, `results/mduck.json`, +`results/mspark.json`, and `results/report.md`. + +### 3 — Read the report + +```bash +cat results/report.md +``` + +Or regenerate it at any time from existing JSON files: + +```bash +python3 report.py --results results +``` + +--- + +## Running individual platforms + +```bash +# MobilityDB only +bash bench_mbdb.sh --data ../data --runs 3 --output results/mbdb.json + +# MobilityDuck only +bash bench_mduck.sh --data ../data --runs 3 --output results/mduck.json + +# MobilitySpark only +bash bench_mspark.sh --data ../data --runs 3 --output results/mspark.json +``` + +Use `--no-load` to skip the data-load step if the tables / file-based database +already exist from a previous run. + +--- + +## File layout + +``` +berlinmod/ + bench/ + bench.sh — orchestrator (calls all three + report.py) + bench_mbdb.sh — MobilityDB timer + bench_mduck.sh — MobilityDuck timer + bench_mspark.sh — MobilitySpark (Spark + BerlinMODBench.java) timer + report.py — reads results/*.json, writes results/report.md + results/ — per-run JSON + report (not committed) + data/ — shared CSV files (vehicles.csv, trips.csv, …) + q01.sql … q17.sql — portable SQL queries (named-function dialect) + qrt.sql — binary round-trip query +setup/ + install_spark.sh — installs Maven + Spark 3.5.4 + generate_data.sh — generates BerlinMOD CSV data via PostgreSQL +``` + +--- + +## Sharing your results + +1. Run `bench.sh` to generate `results/report.md`. +2. Open [Discussion #913](https://github.com/MobilityDB/MobilityDB/discussions/913). +3. Paste the markdown table as a new comment. + +--- + +## Methodology notes + +- **Timing**: wall-clock milliseconds (`date +%s%3N`) around each query invocation, + median of N runs. Data loading is excluded from all timings. +- **MobilityDuck**: queries run against a persistent file-based DuckDB so load time + is paid once, not per query. +- **MobilitySpark**: all queries run in a single `spark-submit` session + (class `BerlinMODBench`); JVM startup is excluded from query timings. +- **SQL**: all three platforms execute identical SQL from the `berlinmod/*.sql` files. + No platform-specific operator symbols — named functions only per the portable + dialect in [Discussion #861](https://github.com/MobilityDB/MobilityDB/discussions/861). diff --git a/berlinmod/bench/bench.sh b/berlinmod/bench/bench.sh new file mode 100755 index 00000000..7321466a --- /dev/null +++ b/berlinmod/bench/bench.sh @@ -0,0 +1,141 @@ +#!/usr/bin/env bash +# BerlinMOD cross-platform benchmark — main entry point +# +# Runs the BerlinMOD portable SQL queries on all three platforms and generates +# a markdown performance report with machine specifications. +# +# Usage: +# ./berlinmod/bench/bench.sh [options] +# +# Options: +# --data DIR Shared CSV data directory (default: berlinmod/data) +# Use setup/generate_data.sh to generate larger datasets. +# --runs N Timed runs per query per platform (default: 3) +# --output DIR Directory for results JSON + report (default: berlinmod/bench/results) +# --dbname NAME PostgreSQL database name (default: berlinmod_bench) +# --duckdb PATH DuckDB binary path (default: duckdb from PATH) +# --spark-submit PATH spark-submit binary (default: spark-submit from PATH) +# --skip-mbdb Skip MobilityDB +# --skip-mduck Skip MobilityDuck +# --skip-mspark Skip MobilitySpark +# +# Quick start (all three platforms, synthetic data): +# ./berlinmod/bench/bench.sh +# +# With real BerlinMOD data: +# ./setup/generate_data.sh --scalefactor 0.005 --output berlinmod/data +# ./berlinmod/bench/bench.sh --data berlinmod/data +# +# Output: +# results/mbdb.json, results/mduck.json, results/mspark.json — raw timings +# results/report.md — markdown table + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +BERLINMOD_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)" + +DATADIR="${BERLINMOD_DIR}/data" +RUNS=3 +OUTDIR="${SCRIPT_DIR}/results" +DBNAME="berlinmod_bench" +DUCKDB="${DUCKDB:-duckdb}" +SPARK_SUBMIT="${SPARK_SUBMIT:-spark-submit}" +RUN_MBDB=true +RUN_MDUCK=true +RUN_MSPARK=true + +while [[ $# -gt 0 ]]; do + case "$1" in + --data) DATADIR="$2"; shift 2 ;; + --runs) RUNS="$2"; shift 2 ;; + --output) OUTDIR="$2"; shift 2 ;; + --dbname) DBNAME="$2"; shift 2 ;; + --duckdb) DUCKDB="$2"; shift 2 ;; + --spark-submit) SPARK_SUBMIT="$2"; shift 2 ;; + --skip-mbdb) RUN_MBDB=false; shift ;; + --skip-mduck) RUN_MDUCK=false; shift ;; + --skip-mspark) RUN_MSPARK=false; shift ;; + *) echo "Unknown option: $1"; exit 1 ;; + esac +done + +mkdir -p "$OUTDIR" + +echo "╔══════════════════════════════════════════════════════╗" +echo "║ BerlinMOD Cross-Platform Benchmark ║" +echo "╚══════════════════════════════════════════════════════╝" +echo "" +echo "Data : $DATADIR" +echo "Runs : $RUNS per query" +echo "Output : $OUTDIR" +echo "" + +# ── MobilityDB ──────────────────────────────────────────────────────────────── +if $RUN_MBDB; then + if ! command -v psql >/dev/null 2>&1; then + echo "[SKIP] MobilityDB — psql not found" + else + echo "──────────────────────────────────────────────────────" + echo " MobilityDB / PostgreSQL" + echo "──────────────────────────────────────────────────────" + "${SCRIPT_DIR}/bench_mbdb.sh" \ + --dbname "$DBNAME" \ + --data "$DATADIR" \ + --runs "$RUNS" \ + --output "${OUTDIR}/mbdb.json" + fi +fi + +# ── MobilityDuck ────────────────────────────────────────────────────────────── +if $RUN_MDUCK; then + if ! command -v "$DUCKDB" >/dev/null 2>&1; then + echo "[SKIP] MobilityDuck — duckdb not found (pass --duckdb PATH)" + else + echo "" + echo "──────────────────────────────────────────────────────" + echo " MobilityDuck / DuckDB" + echo "──────────────────────────────────────────────────────" + "${SCRIPT_DIR}/bench_mduck.sh" \ + --duckdb "$DUCKDB" \ + --data "$DATADIR" \ + --runs "$RUNS" \ + --output "${OUTDIR}/mduck.json" + fi +fi + +# ── MobilitySpark ───────────────────────────────────────────────────────────── +if $RUN_MSPARK; then + if ! command -v "$SPARK_SUBMIT" >/dev/null 2>&1; then + echo "" + echo "[SKIP] MobilitySpark — spark-submit not found" + echo " Run: ${REPO_ROOT}/setup/install_spark.sh" + else + echo "" + echo "──────────────────────────────────────────────────────" + echo " MobilitySpark / Apache Spark" + echo "──────────────────────────────────────────────────────" + "${SCRIPT_DIR}/bench_mspark.sh" \ + --spark-submit "$SPARK_SUBMIT" \ + --data "$DATADIR" \ + --runs "$RUNS" \ + --output "${OUTDIR}/mspark.json" + fi +fi + +# ── Report ──────────────────────────────────────────────────────────────────── +echo "" +echo "──────────────────────────────────────────────────────" +echo " Generating report" +echo "──────────────────────────────────────────────────────" +REPORT="${OUTDIR}/report.md" +python3 "${SCRIPT_DIR}/report.py" \ + --results "$OUTDIR" \ + --output "$REPORT" + +echo "" +echo "╔══════════════════════════════════════════════════════╗" +echo "║ Done. Report: ${REPORT}" +echo "╚══════════════════════════════════════════════════════╝" +echo "" +cat "$REPORT" diff --git a/berlinmod/bench/bench_mbdb.sh b/berlinmod/bench/bench_mbdb.sh new file mode 100755 index 00000000..08efd692 --- /dev/null +++ b/berlinmod/bench/bench_mbdb.sh @@ -0,0 +1,178 @@ +#!/usr/bin/env bash +# BerlinMOD timing runner — MobilityDB / PostgreSQL +# +# Loads data once, runs each query RUNS times, records wall-clock time per run, +# and writes a JSON file suitable for report.py. When --queries is given only +# the selected queries are re-run and merged into an existing output file. +# +# Usage: +# bench_mbdb.sh [options] +# +# Options: +# --dbname NAME PostgreSQL database name (default: berlinmod_bench) +# --data DIR Directory containing the shared CSV files +# --runs N Timed runs per query (default: 3) +# --queries RANGE Comma/range query selector: "q04", "q04,q05", "q02-q05" +# Default: all queries in canonical order +# --output FILE Path to write results JSON (default: results/mbdb.json) +# --no-load Skip data loading (reuse existing tables in DBNAME) +# +# Requirements: +# psql on PATH; MobilityDB installed and available for CREATE EXTENSION. + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +BERLINMOD_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)" + +# ── defaults ────────────────────────────────────────────────────────────────── +DBNAME="berlinmod_bench" +DATADIR="${BERLINMOD_DIR}/data" +RUNS=3 +OUTPUT="${SCRIPT_DIR}/results/mbdb.json" +LOAD=true +QUERIES_ARG="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --dbname) DBNAME="$2"; shift 2 ;; + --data) DATADIR="$2"; shift 2 ;; + --runs) RUNS="$2"; shift 2 ;; + --queries) QUERIES_ARG="$2"; shift 2 ;; + --output) OUTPUT="$2"; shift 2 ;; + --no-load) LOAD=false; shift ;; + *) echo "Unknown option: $1"; exit 1 ;; + esac +done + +ALL_QUERIES=(q01 q02 q03 q04 q05 q06 q07 q08 qrt q09 q10 q11 q12 q13 q14 q15 q16 q17) + +# Resolve QUERIES from QUERIES_ARG (comma/range syntax) or use all +resolve_queries() { + local arg="$1" + if [[ -z "$arg" || "$arg" == "all" ]]; then + echo "${ALL_QUERIES[@]}" + return + fi + local result=() + IFS=',' read -ra tokens <<< "$arg" + for token in "${tokens[@]}"; do + token="${token// /}" + if [[ "$token" == *-* && "$token" != qrt ]]; then + local from to + from="${token%%-*}" + to="${token##*-}" + # Normalize: bare numbers → q0N + [[ "$from" =~ ^[0-9]+$ ]] && from=$(printf "q%02d" "$from") + [[ "$to" =~ ^[0-9]+$ ]] && to=$(printf "q%02d" "$to") + local in_range=false + for q in "${ALL_QUERIES[@]}"; do + [[ "$q" == "$from" ]] && in_range=true + $in_range && result+=("$q") + [[ "$q" == "$to" ]] && in_range=false + done + else + [[ "$token" =~ ^[0-9]+$ ]] && token=$(printf "q%02d" "$token") + result+=("$token") + fi + done + echo "${result[@]}" +} + +QUERIES=($(resolve_queries "$QUERIES_ARG")) + +_psql() { psql -d "$DBNAME" -q "$@"; } + +# ── load data ───────────────────────────────────────────────────────────────── +if $LOAD; then + echo "=== Creating database: $DBNAME ===" + createdb "$DBNAME" 2>/dev/null || true + LOADER=$(mktemp --suffix=.sql) + trap 'rm -f "$LOADER"' EXIT + sed "s|DATADIR|${DATADIR}|g" "${BERLINMOD_DIR}/load_mbdb.sql" > "$LOADER" + echo "=== Loading data ===" + _psql -f "$LOADER" + echo " done." +fi + +# ── version ─────────────────────────────────────────────────────────────────── +MBDB_VER=$(_psql -t -c "SELECT mobilitydb_version();" | tr -d ' \n') +PG_VER=$(_psql -t -c "SELECT version();" | awk '{print $1, $2}' | tr -d '\n') +PLATFORM_VER="${MBDB_VER} on ${PG_VER}" + +TRIP_COUNT=$(_psql -t -c "SELECT count(*) FROM Trips;" | tr -d ' \n') +VEH_COUNT=$(_psql -t -c "SELECT count(*) FROM Vehicles;" | tr -d ' \n') + +QUERIES_MSG="${QUERIES_ARG:-all}" +echo "=== Platform: ${PLATFORM_VER} ===" +echo "=== Dataset : ${VEH_COUNT} vehicles / ${TRIP_COUNT} trips ===" +echo "=== Runs : ${RUNS} per query (queries: ${QUERIES_MSG}) ===" +echo "" + +TIMEFILE=$(mktemp) +trap 'rm -f "$TIMEFILE"' EXIT + +for Q in "${QUERIES[@]}"; do + QFILE="${BERLINMOD_DIR}/${Q}.sql" + [[ -f "$QFILE" ]] || { echo " [skip] ${Q} — SQL file not found"; continue; } + printf " timing %-6s: " "$Q" + for RUN in $(seq 1 "$RUNS"); do + T0=$(date +%s%3N) + _psql -o /dev/null -f "$QFILE" 2>/dev/null || true + T1=$(date +%s%3N) + ELAPSED=$((T1 - T0)) + printf "%d " "$ELAPSED" + echo "${Q} ${ELAPSED}" >> "$TIMEFILE" + done + echo "ms" +done + +mkdir -p "$(dirname "$OUTPUT")" + +# Merge new timings into existing output file (preserving unselected queries) +python3 - "$TIMEFILE" "$OUTPUT" "$PLATFORM_VER" "$TRIP_COUNT" "$VEH_COUNT" "$RUNS" <<'PYEOF' +import sys, json, collections, datetime, os + +timefile, outfile, version, trips, vehicles, runs = \ + sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]), int(sys.argv[5]), int(sys.argv[6]) + +QUERY_ORDER = ["q01","q02","q03","q04","q05","q06","q07","q08","qrt", + "q09","q10","q11","q12","q13","q14","q15","q16","q17"] + +# Load existing results to merge into +existing = {} +if os.path.exists(outfile): + try: + with open(outfile) as f: + existing = json.load(f).get("queries", {}) + except Exception: + pass + +# Override with new timings +new_times = collections.defaultdict(list) +with open(timefile) as f: + for line in f: + parts = line.strip().split() + if len(parts) == 2: + new_times[parts[0]].append(int(parts[1])) +existing.update(new_times) + +# Re-order by canonical order +ordered = {q: existing[q] for q in QUERY_ORDER if q in existing} +for q in existing: + if q not in ordered: + ordered[q] = existing[q] + +result = { + "platform": "mobilitydb", + "version": version, + "data_vehicles": vehicles, + "data_trips": trips, + "runs": runs, + "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"), + "queries": ordered, +} +with open(outfile, "w") as f: + json.dump(result, f, indent=2) + f.write("\n") +print(f"\nResults written to {outfile}") +PYEOF diff --git a/berlinmod/bench/bench_mduck.sh b/berlinmod/bench/bench_mduck.sh new file mode 100755 index 00000000..8df9094c --- /dev/null +++ b/berlinmod/bench/bench_mduck.sh @@ -0,0 +1,189 @@ +#!/usr/bin/env bash +# BerlinMOD timing runner — MobilityDuck / DuckDB +# +# Loads data once into a file-based DuckDB database, runs each query RUNS times, +# and writes a JSON file suitable for report.py. When --queries is given only +# the selected queries are re-run and merged into an existing output file. +# +# Usage: +# bench_mduck.sh [options] +# +# Options: +# --duckdb PATH Path to duckdb binary (default: duckdb from PATH) +# --data DIR Directory containing the shared CSV files +# --runs N Timed runs per query (default: 3) +# --queries RANGE Comma/range query selector: "q04", "q04,q05", "q02-q05" +# Default: all queries in canonical order +# --output FILE Path to write results JSON (default: results/mduck.json) +# --dbfile PATH DuckDB file to use (default: /tmp/berlinmod_bench.duckdb) +# --no-load Skip data loading (reuse existing dbfile) +# +# Requirements: +# duckdb on PATH (or pass --duckdb); MobilityDuck extension loadable. + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +BERLINMOD_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)" + +# ── defaults ────────────────────────────────────────────────────────────────── +DUCKDB="${DUCKDB:-duckdb}" +DATADIR="${BERLINMOD_DIR}/data" +RUNS=3 +OUTPUT="${SCRIPT_DIR}/results/mduck.json" +DBFILE="/tmp/berlinmod_bench.duckdb" +LOAD=true +QUERIES_ARG="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --duckdb) DUCKDB="$2"; shift 2 ;; + --data) DATADIR="$2"; shift 2 ;; + --runs) RUNS="$2"; shift 2 ;; + --queries) QUERIES_ARG="$2"; shift 2 ;; + --output) OUTPUT="$2"; shift 2 ;; + --dbfile) DBFILE="$2"; shift 2 ;; + --no-load) LOAD=false; shift ;; + *) echo "Unknown option: $1"; exit 1 ;; + esac +done + +ALL_QUERIES=(q01 q02 q03 q04 q05 q06 q07 q08 qrt q09 q10 q11 q12 q13 q14 q15 q16 q17) + +# Resolve QUERIES from QUERIES_ARG (comma/range syntax) or use all +resolve_queries() { + local arg="$1" + if [[ -z "$arg" || "$arg" == "all" ]]; then + echo "${ALL_QUERIES[@]}" + return + fi + local result=() + IFS=',' read -ra tokens <<< "$arg" + for token in "${tokens[@]}"; do + token="${token// /}" + if [[ "$token" == *-* && "$token" != qrt ]]; then + local from to + from="${token%%-*}" + to="${token##*-}" + [[ "$from" =~ ^[0-9]+$ ]] && from=$(printf "q%02d" "$from") + [[ "$to" =~ ^[0-9]+$ ]] && to=$(printf "q%02d" "$to") + local in_range=false + for q in "${ALL_QUERIES[@]}"; do + [[ "$q" == "$from" ]] && in_range=true + $in_range && result+=("$q") + [[ "$q" == "$to" ]] && in_range=false + done + else + [[ "$token" =~ ^[0-9]+$ ]] && token=$(printf "q%02d" "$token") + result+=("$token") + fi + done + echo "${result[@]}" +} + +QUERIES=($(resolve_queries "$QUERIES_ARG")) + +# Detect local vs community MobilityDuck build +DUCKDB_ABS="$(command -v "$DUCKDB" 2>/dev/null || echo "$DUCKDB")" +DUCKDB_DIR="$(cd "$(dirname "$DUCKDB_ABS")" 2>/dev/null && pwd || true)" +if [ -d "${DUCKDB_DIR}/extension/mobilityduck" ]; then + MOBILITY_LOAD="LOAD mobilityduck;" +else + MOBILITY_LOAD="INSTALL mobilitydb FROM community; LOAD mobilitydb;" +fi + +_duck() { "$DUCKDB" "$DBFILE" -c "$1" 2>/dev/null; } +_duck_q() { "$DUCKDB" "$DBFILE" -noheader -list -c "$1" 2>/dev/null; } + +# ── load data ───────────────────────────────────────────────────────────────── +if $LOAD; then + echo "=== Loading data into: $DBFILE ===" + rm -f "$DBFILE" + LOAD_BODY="$(sed '/^SET VARIABLE DATADIR/d' "${BERLINMOD_DIR}/load_mduck.sql")" + LOAD_SQL="${MOBILITY_LOAD} SET VARIABLE DATADIR='${DATADIR}/'; ${LOAD_BODY}" + "$DUCKDB" "$DBFILE" -c "$LOAD_SQL" + echo " done." +fi + +# ── version ─────────────────────────────────────────────────────────────────── +MDUCK_VER=$(_duck_q "SELECT mobilityduck_version();" 2>/dev/null | head -1 || echo "unknown") +DUCK_VER=$(_duck_q "SELECT version();" 2>/dev/null | head -1 || echo "unknown") +PLATFORM_VER="${MDUCK_VER} on DuckDB ${DUCK_VER}" + +TRIP_COUNT=$(_duck_q "SELECT count(*) FROM Trips;" || echo 0) +VEH_COUNT=$( _duck_q "SELECT count(*) FROM Vehicles;" || echo 0) + +QUERIES_MSG="${QUERIES_ARG:-all}" +echo "=== Platform: ${PLATFORM_VER} ===" +echo "=== Dataset : ${VEH_COUNT} vehicles / ${TRIP_COUNT} trips ===" +echo "=== Runs : ${RUNS} per query (queries: ${QUERIES_MSG}) ===" +echo "" + +TIMEFILE=$(mktemp) +trap 'rm -f "$TIMEFILE"' EXIT + +for Q in "${QUERIES[@]}"; do + QFILE="${BERLINMOD_DIR}/${Q}.sql" + [[ -f "$QFILE" ]] || { echo " [skip] ${Q} — SQL file not found"; continue; } + QSQL=$(grep -v '^\s*--' "$QFILE" | tr '\n' ' ') + printf " timing %-6s: " "$Q" + for RUN in $(seq 1 "$RUNS"); do + T0=$(date +%s%3N) + "$DUCKDB" "$DBFILE" -c "${MOBILITY_LOAD} SET search_path='portable,main'; ${QSQL}" \ + > /dev/null 2>&1 || true + T1=$(date +%s%3N) + ELAPSED=$((T1 - T0)) + printf "%d " "$ELAPSED" + echo "${Q} ${ELAPSED}" >> "$TIMEFILE" + done + echo "ms" +done + +mkdir -p "$(dirname "$OUTPUT")" + +# Merge new timings into existing output file (preserving unselected queries) +python3 - "$TIMEFILE" "$OUTPUT" "$PLATFORM_VER" "$TRIP_COUNT" "$VEH_COUNT" "$RUNS" <<'PYEOF' +import sys, json, collections, datetime, os + +timefile, outfile, version, trips, vehicles, runs = \ + sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]), int(sys.argv[5]), int(sys.argv[6]) + +QUERY_ORDER = ["q01","q02","q03","q04","q05","q06","q07","q08","qrt", + "q09","q10","q11","q12","q13","q14","q15","q16","q17"] + +existing = {} +if os.path.exists(outfile): + try: + with open(outfile) as f: + existing = json.load(f).get("queries", {}) + except Exception: + pass + +new_times = collections.defaultdict(list) +with open(timefile) as f: + for line in f: + parts = line.strip().split() + if len(parts) == 2: + ms = int(parts[1]) + if ms > 0: + new_times[parts[0]].append(ms) +existing.update(new_times) + +ordered = {q: existing[q] for q in QUERY_ORDER if q in existing} +for q in existing: + if q not in ordered: + ordered[q] = existing[q] + +result = { + "platform": "mobilityduck", + "version": version, + "data_vehicles": vehicles, + "data_trips": trips, + "runs": runs, + "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"), + "queries": ordered, +} +with open(outfile, "w") as f: + json.dump(result, f, indent=2) + f.write("\n") +print(f"\nResults written to {outfile}") +PYEOF diff --git a/berlinmod/bench/bench_mspark.sh b/berlinmod/bench/bench_mspark.sh new file mode 100755 index 00000000..676b8f5f --- /dev/null +++ b/berlinmod/bench/bench_mspark.sh @@ -0,0 +1,116 @@ +#!/usr/bin/env bash +# BerlinMOD timing runner — MobilitySpark / Apache Spark +# +# Builds the fat JAR if necessary, then runs BerlinMODBench in a single +# Spark session (avoiding JVM startup overhead per query). BerlinMODBench +# writes a JSON results file directly. +# +# Usage: +# bench_mspark.sh [options] +# +# Options: +# --spark-submit PATH Path to spark-submit binary (default: spark-submit from PATH) +# --data DIR Directory containing the shared CSV files +# --runs N Timed runs per query (default: 3) +# --quick Run each query once (--runs 1); useful for crash-safety checks +# --queries RANGE Page-range query selector: "3", "2-5", "q02-q05", "qrt", "q04,qrt" +# Default: all queries in canonical order +# --output FILE Path to write results JSON (default: results/mspark.json) +# --jar PATH Pre-built fat JAR (skip mvn build) +# +# Requirements: +# spark-submit on PATH (or --spark-submit); Java 11/17/21; Maven for building. +# Run setup/install_spark.sh if spark-submit is missing. + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +BERLINMOD_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)" + +# ── defaults ────────────────────────────────────────────────────────────────── +SPARK_SUBMIT="${SPARK_SUBMIT:-spark-submit}" +DATADIR="${BERLINMOD_DIR}/data" +RUNS=3 +OUTPUT="${SCRIPT_DIR}/results/mspark.json" +QUERIES="" +JAR="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --spark-submit) SPARK_SUBMIT="$2"; shift 2 ;; + --data) DATADIR="$2"; shift 2 ;; + --runs) RUNS="$2"; shift 2 ;; + --quick) RUNS=1; shift ;; + --queries) QUERIES="$2"; shift 2 ;; + --output) OUTPUT="$2"; shift 2 ;; + --jar) JAR="$2"; shift 2 ;; + *) echo "Unknown option: $1"; exit 1 ;; + esac +done + +# ── verify spark-submit ─────────────────────────────────────────────────────── +if ! command -v "$SPARK_SUBMIT" >/dev/null 2>&1; then + echo "ERROR: spark-submit not found." + echo " Run: ${REPO_ROOT}/setup/install_spark.sh" + echo " or pass: --spark-submit /opt/spark/bin/spark-submit" + exit 1 +fi + +# ── build fat JAR if needed ─────────────────────────────────────────────────── +if [[ -z "$JAR" ]]; then + JAR=$(ls "${REPO_ROOT}/target/"*-spark.jar 2>/dev/null | head -1 || true) +fi + +if [[ -z "$JAR" ]]; then + echo "=== No fat JAR found — building with mvn package ===" + if ! command -v mvn >/dev/null 2>&1; then + echo "ERROR: mvn not found. Install Maven:" + echo " sudo apt-get install -y maven" + exit 1 + fi + (cd "$REPO_ROOT" && mvn package -DskipTests -q) + JAR=$(ls "${REPO_ROOT}/target/"*-spark.jar | head -1) +fi +echo "=== Using JAR: $JAR ===" + +LIBMEOS_DIR="${LIBMEOS_DIR:-/usr/local/lib}" + +mkdir -p "$(dirname "$OUTPUT")" + +# Suppress core dumps: a JVM crash produces a 3-5 GB core file that can OOM WSL2. +ulimit -c 0 + +QUERIES_MSG="${QUERIES:-all}" +echo "=== Running BerlinMODBench (${RUNS} runs/query, queries=${QUERIES_MSG}) on MobilitySpark ===" +# --driver-memory 6g: each BerlinMOD trip row is ~36 KB hex-WKB; cross-join queries (Q2, Q4) +# hold ~1 GB of trip strings in heap simultaneously. A 6 g heap gives the GC enough headroom +# to avoid spilling to off-heap and prevents WSL2 OOM kills when queries run back-to-back. +# +# --conf spark.sql.autoBroadcastJoinThreshold=200m: BerlinMOD's small dimension +# tables (Vehicles, QueryPoints, QueryRegions, QueryInstants, QueryPeriods, +# QueryLicences) are all under 200 KB; broadcasting them is always profitable +# but the default 10 MB threshold occasionally falls back to shuffle when +# Catalyst's size estimate is conservative (e.g. on a cached relational plan). +# 200 m makes broadcast the deterministic choice for these dim tables. +# +# --conf spark.sql.adaptive.enabled=true / .skewJoin.enabled: Adaptive Query +# Execution can convert sort-merge joins to broadcast joins at runtime once +# actual table sizes are known, and rebalance skewed join keys. Useful for +# Q10/Q11/Q12 where one side of a Trips×Trips Cartesian-style join has a +# small materialised intermediate (e.g. WITH Temp AS (...)). +"$SPARK_SUBMIT" \ + --class org.mobilitydb.spark.demo.BerlinMODBench \ + --master "local[2]" \ + --driver-memory 6g \ + --conf "spark.driver.extraJavaOptions=-Djava.library.path=${LIBMEOS_DIR} -Dlog4j.logger.org.apache=WARN" \ + --conf "spark.sql.autoBroadcastJoinThreshold=200m" \ + --conf "spark.sql.adaptive.enabled=true" \ + --conf "spark.sql.adaptive.skewJoin.enabled=true" \ + --conf "spark.sql.adaptive.coalescePartitions.enabled=true" \ + "$JAR" \ + "$DATADIR" \ + "$OUTPUT" \ + "$RUNS" \ + ${QUERIES:+"$QUERIES"} + +echo "=== Results written to ${OUTPUT} ===" diff --git a/berlinmod/bench/report.py b/berlinmod/bench/report.py new file mode 100644 index 00000000..b60de93a --- /dev/null +++ b/berlinmod/bench/report.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 +""" +BerlinMOD cross-platform benchmark report generator. + +Reads JSON result files produced by bench_mbdb.sh, bench_mduck.sh, and +bench_mspark.sh, collects machine specifications, and writes a self-contained +markdown table. + +Usage: + report.py --results DIR [--output FILE] + +Reads: DIR/mbdb.json, DIR/mduck.json, DIR/mspark.json (any subset is fine) +Writes: FILE (default: DIR/report.md) + +To share your results with the MobilityDB community, paste the generated +markdown table as a comment on: + https://github.com/MobilityDB/MobilityDB/discussions/913 +""" + +import argparse +import json +import os +import platform +import statistics +import subprocess +import sys +from pathlib import Path +from datetime import datetime, timezone + + +# Canonical query order and short descriptions +QUERY_LABELS = { + "q01": "Q1 — vehicle models (relational join)", + "q02": "Q2 — ever entered region (eIntersects)", + "q03": "Q3 — position at instant (atTime)", + "q04": "Q4 — ever passed point (eIntersects)", + "q05": "Q5 — min approach distance (nearestApproachDistance)", + "q06": "Q6 — truck pairs within 10 m (eDwithin)", + "q07": "Q7 — trip during period (atTime)", + "q08": "Q8 — trajectory geometry (trajectory)", + "qrt": "QRT — binary round-trip (asHexWKB)", + "q09": "Q9 — licence + region ever-intersect", + "q10": "Q10 — licence + point ever-intersect", + "q11": "Q11 — licence + period overlap", + "q12": "Q12 — vehicles ever in multiple regions", + "q13": "Q13 — pairs ever within 10 m", + "q14": "Q14 — vehicles with max speed > threshold", + "q15": "Q15 — distance travelled per vehicle", + "q16": "Q16 — vehicles present during each period", + "q17": "Q17 — aggregate: trips per vehicle type", +} + + +def median_ms(times: list[int]) -> float: + return statistics.median(times) + + +def fmt_ms(ms: float) -> str: + if ms < 1000: + return f"{ms:.0f} ms" + return f"{ms / 1000:.2f} s" + + +def collect_machine_spec() -> dict: + spec: dict = {} + + # CPU model + try: + with open("/proc/cpuinfo") as f: + for line in f: + if "model name" in line: + spec["cpu"] = line.split(":")[1].strip() + break + except OSError: + spec["cpu"] = platform.processor() or "unknown" + + # Core / thread count + try: + cores = int(subprocess.check_output( + ["nproc", "--all"], text=True).strip()) + physical = int(subprocess.check_output( + "grep -c '^processor' /proc/cpuinfo", shell=True, text=True).strip()) + spec["threads"] = physical + spec["cores"] = cores // 2 if cores != physical else cores + except Exception: + spec["threads"] = os.cpu_count() or 1 + spec["cores"] = spec["threads"] + + # RAM + try: + with open("/proc/meminfo") as f: + for line in f: + if "MemTotal" in line: + kb = int(line.split()[1]) + spec["ram_gb"] = round(kb / 1024 / 1024, 1) + break + except OSError: + spec["ram_gb"] = "unknown" + + # OS + try: + uname = platform.uname() + spec["os"] = f"{uname.system} {uname.release}" + if "microsoft" in uname.release.lower(): + spec["os"] += " (WSL2)" + except Exception: + spec["os"] = platform.platform() + + # Python + spec["python"] = platform.python_version() + + return spec + + +def load_results(results_dir: Path) -> dict[str, dict]: + platforms = {} + for fname, key in [("mbdb.json", "mobilitydb"), + ("mduck.json", "mobilityduck"), + ("mspark.json", "mobilityspark")]: + path = results_dir / fname + if path.exists(): + with open(path) as f: + data = json.load(f) + platforms[key] = data + return platforms + + +def build_report(platforms: dict[str, dict], machine: dict) -> str: + lines = [] + + # Header + lines.append("## BerlinMOD Portable SQL — Cross-Platform Benchmark") + lines.append("") + now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC") + lines.append(f"*Generated {now}*") + lines.append("") + + # Machine specs + lines.append("### Machine") + lines.append("") + lines.append("| Parameter | Value |") + lines.append("|---|---|") + lines.append(f"| CPU | {machine.get('cpu', 'unknown')} |") + cores = machine.get('cores', '?') + threads = machine.get('threads', '?') + lines.append(f"| Cores / threads | {cores} cores / {threads} threads |") + lines.append(f"| RAM | {machine.get('ram_gb', '?')} GB |") + lines.append(f"| OS | {machine.get('os', 'unknown')} |") + lines.append("") + + if not platforms: + lines.append("*No result files found in the results directory.*") + return "\n".join(lines) + + # Platform versions + data size + lines.append("### Platforms") + lines.append("") + lines.append("| Platform | Version | Vehicles | Trips | Runs |") + lines.append("|---|---|---|---|---|") + DISPLAY = { + "mobilitydb": "MobilityDB", + "mobilityduck": "MobilityDuck", + "mobilityspark": "MobilitySpark", + } + for key in ["mobilitydb", "mobilityduck", "mobilityspark"]: + if key not in platforms: + continue + d = platforms[key] + lines.append( + f"| {DISPLAY[key]} | {d.get('version','?')} " + f"| {d.get('data_vehicles','?')} " + f"| {d.get('data_trips','?')} " + f"| {d.get('runs','?')} |" + ) + lines.append("") + + # Timing table + present = [k for k in ["mobilitydb", "mobilityduck", "mobilityspark"] + if k in platforms] + header = "| Query | Description |" + "".join( + f" {DISPLAY[k]} |" for k in present) + lines.append("### Query Timings (median wall-clock)") + lines.append("") + lines.append(header) + lines.append("|---|---|" + "---|" * len(present)) + + all_queries = list(QUERY_LABELS.keys()) + for q in all_queries: + # include row only if at least one platform has data for this query + cells = {} + for k in present: + times = platforms[k].get("queries", {}).get(q) + cells[k] = fmt_ms(median_ms(times)) if times else "—" + if all(v == "—" for v in cells.values()): + continue + label = QUERY_LABELS.get(q, q) + row = f"| `{q}` | {label} |" + for k in present: + row += f" {cells[k]} |" + lines.append(row) + + lines.append("") + + # Notes + lines.append("### Notes") + lines.append("") + lines.append("- All three platforms use **identical SQL** (no operator symbols — " + "named functions only per the portable dialect in Discussion #861).") + lines.append("- Timings are wall-clock (client-side `date +%s%3N`), " + "median of N runs. Data loading is excluded.") + lines.append("- MobilitySpark timings include Spark query planning overhead " + "but **not** JVM startup (all queries run in a single Spark session).") + lines.append("- Queries marked `—` are not yet implemented on that platform.") + lines.append("") + lines.append("To share your results, paste this table as a comment on " + "https://github.com/MobilityDB/MobilityDB/discussions/913") + lines.append("") + + return "\n".join(lines) + + +def main(): + parser = argparse.ArgumentParser(description="BerlinMOD benchmark report generator") + parser.add_argument("--results", default="results", + help="Directory containing mbdb.json / mduck.json / mspark.json") + parser.add_argument("--output", default=None, + help="Output markdown file (default: RESULTS/report.md)") + args = parser.parse_args() + + results_dir = Path(args.results) + output_path = Path(args.output) if args.output else results_dir / "report.md" + + platforms = load_results(results_dir) + if not platforms: + print(f"No result files found in {results_dir}/", file=sys.stderr) + print("Run bench.sh (or individual bench_*.sh scripts) first.", file=sys.stderr) + sys.exit(1) + + machine = collect_machine_spec() + report = build_report(platforms, machine) + + output_path.parent.mkdir(parents=True, exist_ok=True) + output_path.write_text(report) + print(f"Report written to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/berlinmod/bench/results/.gitkeep b/berlinmod/bench/results/.gitkeep new file mode 100644 index 00000000..e69de29b diff --git a/berlinmod/data/query_instants.csv b/berlinmod/data/query_instants.csv new file mode 100644 index 00000000..1d1c3363 --- /dev/null +++ b/berlinmod/data/query_instants.csv @@ -0,0 +1,101 @@ +instantid,instant +1,2020-06-01 10:29:42.668208+02 +2,2020-06-02 20:27:52.353226+02 +3,2020-06-03 22:04:46.124268+02 +4,2020-06-02 12:36:02.624752+02 +5,2020-06-03 05:49:40.344492+02 +6,2020-06-03 07:20:48.048547+02 +7,2020-06-04 12:08:46.700004+02 +8,2020-06-01 14:31:24.948783+02 +9,2020-06-03 09:45:52.123591+02 +10,2020-06-02 15:59:23.076796+02 +11,2020-06-01 05:13:45.813282+02 +12,2020-06-02 19:19:02.01991+02 +13,2020-06-03 17:11:44.410118+02 +14,2020-06-03 17:44:33.133116+02 +15,2020-06-03 00:15:42.076547+02 +16,2020-06-04 02:31:43.561175+02 +17,2020-06-03 01:55:37.533793+02 +18,2020-06-02 16:39:31.228338+02 +19,2020-06-03 02:09:55.488606+02 +20,2020-06-02 03:31:57.422845+02 +21,2020-06-01 12:58:31.246676+02 +22,2020-06-04 17:19:33.883765+02 +23,2020-06-04 02:23:00.715414+02 +24,2020-06-04 07:34:22.352481+02 +25,2020-06-03 16:57:16.406968+02 +26,2020-06-03 16:32:59.746607+02 +27,2020-06-02 08:44:57.399553+02 +28,2020-06-01 10:28:14.405822+02 +29,2020-06-03 03:48:52.700575+02 +30,2020-06-01 05:00:50.702899+02 +31,2020-06-02 17:39:00.146159+02 +32,2020-06-04 20:51:42.977565+02 +33,2020-06-02 14:45:20.845265+02 +34,2020-06-02 03:12:47.108368+02 +35,2020-06-02 20:11:22.877791+02 +36,2020-06-03 23:37:22.951699+02 +37,2020-06-02 11:53:39.168415+02 +38,2020-06-01 04:27:33.776204+02 +39,2020-06-03 01:55:54.912397+02 +40,2020-06-03 04:04:48.590671+02 +41,2020-06-04 02:25:12.342898+02 +42,2020-06-04 04:43:48.960341+02 +43,2020-06-01 19:45:13.341786+02 +44,2020-06-02 19:37:06.686603+02 +45,2020-06-04 14:32:33.1709+02 +46,2020-06-04 07:42:35.120571+02 +47,2020-06-03 17:10:17.529879+02 +48,2020-06-03 02:47:47.839108+02 +49,2020-06-04 08:35:23.527843+02 +50,2020-06-02 01:02:38.89768+02 +51,2020-06-04 11:18:31.252106+02 +52,2020-06-03 05:22:50.418978+02 +53,2020-06-04 04:05:30.507108+02 +54,2020-06-04 17:04:35.686283+02 +55,2020-06-02 08:15:19.619701+02 +56,2020-06-02 23:30:51.533321+02 +57,2020-06-03 06:27:40.120518+02 +58,2020-06-01 00:21:20.385887+02 +59,2020-06-01 22:43:36.395295+02 +60,2020-06-03 20:11:48.483564+02 +61,2020-06-03 20:48:01.785238+02 +62,2020-06-03 09:58:13.274191+02 +63,2020-06-01 03:57:00.540756+02 +64,2020-06-02 07:42:00.271145+02 +65,2020-06-02 17:50:24.052624+02 +66,2020-06-03 03:57:47.292374+02 +67,2020-06-01 20:15:17.212234+02 +68,2020-06-02 22:29:49.412167+02 +69,2020-06-02 23:41:59.858617+02 +70,2020-06-01 17:14:21.780877+02 +71,2020-06-02 21:32:04.789647+02 +72,2020-06-02 03:36:14.37843+02 +73,2020-06-01 11:36:02.870538+02 +74,2020-06-03 02:09:34.753558+02 +75,2020-06-02 08:26:08.705261+02 +76,2020-06-04 21:33:40.917597+02 +77,2020-06-04 08:34:51.24989+02 +78,2020-06-01 06:51:20.796587+02 +79,2020-06-03 12:24:41.512348+02 +80,2020-06-04 00:18:58.284549+02 +81,2020-06-03 07:11:16.096414+02 +82,2020-06-02 16:14:29.902331+02 +83,2020-06-03 17:02:28.37436+02 +84,2020-06-03 08:48:29.416139+02 +85,2020-06-02 03:32:51.369431+02 +86,2020-06-03 20:29:34.899425+02 +87,2020-06-04 21:18:25.313371+02 +88,2020-06-04 17:45:47.335365+02 +89,2020-06-01 06:55:24.264288+02 +90,2020-06-01 12:01:58.670175+02 +91,2020-06-02 19:32:49.037595+02 +92,2020-06-03 05:36:26.829635+02 +93,2020-06-03 15:46:39.896587+02 +94,2020-06-02 08:17:26.240044+02 +95,2020-06-02 07:47:11.319652+02 +96,2020-06-01 23:06:15.468882+02 +97,2020-06-01 02:39:45.356024+02 +98,2020-06-04 18:26:22.189001+02 +99,2020-06-03 03:02:20.190043+02 +100,2020-06-02 21:33:11.597407+02 diff --git a/berlinmod/data/query_licences.csv b/berlinmod/data/query_licences.csv new file mode 100644 index 00000000..59fa0c15 --- /dev/null +++ b/berlinmod/data/query_licences.csv @@ -0,0 +1,101 @@ +licenceid,licence +1,B-MF 24 +2,B-BY 50 +3,B-YT 16 +4,B-JM 119 +5,B-PI 21 +6,B-ZL 134 +7,B-IG 12 +8,B-EP 28 +9,B-FT 29 +10,B-YF 124 +11,B-CK 4 +12,B-QB 34 +13,B-LC 94 +14,B-EP 28 +15,B-ZL 134 +16,B-DB 20 +17,B-IY 73 +18,B-ZT 30 +19,B-KH 14 +20,B-MD 101 +21,B-FT 29 +22,B-ZL 78 +23,B-EU 89 +24,B-RN 92 +25,B-ZN 7 +26,B-UN 79 +27,B-TD 126 +28,B-MD 101 +29,B-LZ 31 +30,B-IQ 116 +31,B-PI 21 +32,B-MG 65 +33,B-QW 58 +34,B-KM 90 +35,B-WE 91 +36,B-OU 2 +37,B-UM 3 +38,B-QB 34 +39,B-FF 56 +40,B-ZE 32 +41,B-[Y 107 +42,B-OU 48 +43,B-EF 1 +44,B-WE 83 +45,B-MU 41 +46,B-WV 137 +47,B-DJ 8 +48,B-WE 91 +49,B-DJ 8 +50,B-MF 24 +51,B-ZN 7 +52,B-NU 11 +53,B-SU 136 +54,B-IX 74 +55,B-OG 64 +56,B-NU 11 +57,B-[J 127 +58,B-JP 138 +59,B-HW 80 +60,B-OD 141 +61,B-YR 120 +62,B-HQ 81 +63,B-PL 128 +64,B-FT 29 +65,B-CW 75 +66,B-OC 43 +67,B-FF 114 +68,B-ZL 78 +69,B-PL 128 +70,B-WZ 19 +71,B-BP 125 +72,B-ME 105 +73,B-MG 65 +74,B-QB 34 +75,B-WC 47 +76,B-XQ 85 +77,B-KI 60 +78,B-OU 2 +79,B-YR 120 +80,B-WV 137 +81,B-FF 114 +82,B-WI 104 +83,B-OU 2 +84,B-DJ 8 +85,B-KF 100 +86,B-ZY 6 +87,B-XC 106 +88,B-ZY 6 +89,B-XD 67 +90,B-HW 80 +91,B-RJ 63 +92,B-IS 121 +93,B-JM 76 +94,B-DD 10 +95,B-UN 79 +96,B-ZY 6 +97,B-ZY 6 +98,B-EM 62 +99,B-WI 104 +100,B-WH 37 diff --git a/berlinmod/data/query_periods.csv b/berlinmod/data/query_periods.csv new file mode 100644 index 00000000..8d1761e9 --- /dev/null +++ b/berlinmod/data/query_periods.csv @@ -0,0 +1,101 @@ +periodid,period +1,"[2020-06-01 16:22:05.582678+02, 2020-06-02 04:15:31.671994+02]" +2,"[2020-06-02 17:15:09.085295+02, 2020-06-02 19:04:26.119882+02]" +3,"[2020-06-01 00:00:07.969134+02, 2020-06-01 14:56:50.846603+02]" +4,"[2020-06-03 21:27:43.364848+02, 2020-06-05 21:00:01.311949+02]" +5,"[2020-06-01 16:52:24.292322+02, 2020-06-02 17:01:28.733421+02]" +6,"[2020-06-01 09:07:48.255855+02, 2020-06-02 05:57:36.144915+02]" +7,"[2020-06-04 22:22:19.668672+02, 2020-06-04 22:24:55.092341+02]" +8,"[2020-06-03 10:01:11.421063+02, 2020-06-04 20:33:04.172466+02]" +9,"[2020-06-01 05:13:10.82024+02, 2020-06-02 21:34:07.854029+02]" +10,"[2020-06-01 00:54:52.973368+02, 2020-06-01 07:43:18.218907+02]" +11,"[2020-06-03 12:09:37.885716+02, 2020-06-03 18:00:01.86282+02]" +12,"[2020-06-01 15:14:08.683251+02, 2020-06-02 10:11:06.511861+02]" +13,"[2020-06-04 08:17:32.185886+02, 2020-06-05 12:30:48.512241+02]" +14,"[2020-06-04 06:01:50.980746+02, 2020-06-04 20:45:43.129721+02]" +15,"[2020-06-03 22:38:58.175392+02, 2020-06-04 07:11:10.173748+02]" +16,"[2020-06-02 17:22:59.363343+02, 2020-06-02 19:23:01.462715+02]" +17,"[2020-06-01 01:59:15.967677+02, 2020-06-01 04:12:15.853773+02]" +18,"[2020-06-03 07:38:22.93281+02, 2020-06-03 11:53:51.18605+02]" +19,"[2020-06-02 12:42:43.417378+02, 2020-06-04 09:29:43.220188+02]" +20,"[2020-06-01 03:13:37.453954+02, 2020-06-02 20:32:29.248517+02]" +21,"[2020-06-03 00:09:59.768704+02, 2020-06-03 20:06:09.066073+02]" +22,"[2020-06-02 16:24:46.06432+02, 2020-06-02 23:43:38.991886+02]" +23,"[2020-06-04 13:00:36.251926+02, 2020-06-04 19:18:18.054758+02]" +24,"[2020-06-02 13:03:59.360118+02, 2020-06-02 15:13:19.173873+02]" +25,"[2020-06-04 16:32:00.93247+02, 2020-06-04 17:44:35.85164+02]" +26,"[2020-06-04 06:23:01.437859+02, 2020-06-05 02:38:26.375588+02]" +27,"[2020-06-04 08:11:40.524508+02, 2020-06-05 07:20:53.692521+02]" +28,"[2020-06-01 02:03:50.406016+02, 2020-06-01 05:53:48.704852+02]" +29,"[2020-06-02 00:42:05.097125+02, 2020-06-02 23:15:51.842667+02]" +30,"[2020-06-01 18:44:26.438928+02, 2020-06-02 02:32:49.440503+02]" +31,"[2020-06-04 07:49:15.636712+02, 2020-06-04 20:33:15.127228+02]" +32,"[2020-06-02 07:09:03.387935+02, 2020-06-02 14:38:23.727871+02]" +33,"[2020-06-04 20:58:40.86382+02, 2020-06-05 14:11:50.238987+02]" +34,"[2020-06-01 22:48:32.100376+02, 2020-06-02 09:52:07.113208+02]" +35,"[2020-06-04 12:16:58.286546+02, 2020-06-05 18:50:21.241567+02]" +36,"[2020-06-02 12:58:17.32439+02, 2020-06-03 23:17:36.154968+02]" +37,"[2020-06-01 21:10:40.017557+02, 2020-06-02 06:34:23.615534+02]" +38,"[2020-06-02 20:50:31.497059+02, 2020-06-05 00:48:42.188374+02]" +39,"[2020-06-03 02:09:06.87443+02, 2020-06-04 10:42:17.478334+02]" +40,"[2020-06-02 00:15:12.417788+02, 2020-06-02 02:40:20.63499+02]" +41,"[2020-06-03 02:55:38.243353+02, 2020-06-03 14:37:12.733115+02]" +42,"[2020-06-01 18:42:54.150127+02, 2020-06-02 21:08:29.338328+02]" +43,"[2020-06-02 19:39:38.170567+02, 2020-06-03 10:33:59.547477+02]" +44,"[2020-06-02 22:03:59.849575+02, 2020-06-03 14:26:13.980392+02]" +45,"[2020-06-01 23:56:34.917523+02, 2020-06-03 14:22:04.016755+02]" +46,"[2020-06-04 13:56:44.007603+02, 2020-06-04 17:46:08.903863+02]" +47,"[2020-06-02 05:15:52.734485+02, 2020-06-02 22:56:55.455569+02]" +48,"[2020-06-01 05:58:44.944983+02, 2020-06-02 15:05:02.998673+02]" +49,"[2020-06-01 08:39:17.608754+02, 2020-06-02 14:49:44.085287+02]" +50,"[2020-06-01 17:50:25.031+02, 2020-06-01 23:51:59.213961+02]" +51,"[2020-06-03 07:33:00.230585+02, 2020-06-04 15:18:27.905581+02]" +52,"[2020-06-01 11:16:38.737871+02, 2020-06-02 11:19:53.971283+02]" +53,"[2020-06-03 23:38:20.774046+02, 2020-06-06 14:27:07.072091+02]" +54,"[2020-06-02 04:34:38.027053+02, 2020-06-02 15:12:17.617008+02]" +55,"[2020-06-01 18:34:46.514998+02, 2020-06-03 06:28:57.281625+02]" +56,"[2020-06-03 02:34:31.256928+02, 2020-06-04 14:20:12.105413+02]" +57,"[2020-06-01 08:40:10.334184+02, 2020-06-01 17:44:03.055403+02]" +58,"[2020-06-04 16:01:15.357686+02, 2020-06-04 16:06:10.160159+02]" +59,"[2020-06-01 06:05:12.160075+02, 2020-06-02 07:26:52.893822+02]" +60,"[2020-06-02 03:53:05.713589+02, 2020-06-02 11:00:11.626419+02]" +61,"[2020-06-02 14:31:58.917735+02, 2020-06-04 01:43:47.402931+02]" +62,"[2020-06-04 23:00:45.398216+02, 2020-06-05 22:17:48.723309+02]" +63,"[2020-06-03 08:43:00.184414+02, 2020-06-04 10:32:00.058112+02]" +64,"[2020-06-03 00:23:42.066505+02, 2020-06-04 09:30:22.223542+02]" +65,"[2020-06-02 20:48:04.652312+02, 2020-06-03 03:57:13.168467+02]" +66,"[2020-06-03 19:43:42.542699+02, 2020-06-06 00:12:35.409028+02]" +67,"[2020-06-01 03:38:13.168549+02, 2020-06-01 15:54:20.433289+02]" +68,"[2020-06-03 04:36:49.837261+02, 2020-06-03 11:50:27.15509+02]" +69,"[2020-06-04 09:57:22.743148+02, 2020-06-04 13:01:00.908499+02]" +70,"[2020-06-01 14:30:47.543216+02, 2020-06-01 18:25:54.657599+02]" +71,"[2020-06-04 08:21:05.74266+02, 2020-06-04 13:20:12.053097+02]" +72,"[2020-06-04 13:31:38.430601+02, 2020-06-06 18:32:17.630379+02]" +73,"[2020-06-02 07:23:34.002778+02, 2020-06-04 01:09:50.003286+02]" +74,"[2020-06-03 10:11:23.214959+02, 2020-06-04 21:52:00.49021+02]" +75,"[2020-06-03 14:50:47.827626+02, 2020-06-04 16:20:52.690954+02]" +76,"[2020-06-02 15:02:02.715193+02, 2020-06-02 17:09:44.737542+02]" +77,"[2020-06-01 18:36:32.251529+02, 2020-06-01 23:40:47.009065+02]" +78,"[2020-06-02 10:57:10.22662+02, 2020-06-03 20:58:57.495064+02]" +79,"[2020-06-04 18:12:10.01532+02, 2020-06-06 05:50:32.955409+02]" +80,"[2020-06-01 03:42:52.213425+02, 2020-06-01 05:09:44.138633+02]" +81,"[2020-06-03 19:49:48.613428+02, 2020-06-03 23:33:54.365863+02]" +82,"[2020-06-02 08:49:49.730063+02, 2020-06-03 08:56:16.65788+02]" +83,"[2020-06-01 07:19:33.821723+02, 2020-06-02 17:30:26.640646+02]" +84,"[2020-06-02 12:18:07.132269+02, 2020-06-03 11:02:01.491414+02]" +85,"[2020-06-01 03:53:43.24965+02, 2020-06-01 06:05:37.758765+02]" +86,"[2020-06-03 02:48:19.133396+02, 2020-06-03 08:50:16.291205+02]" +87,"[2020-06-04 10:28:21.893574+02, 2020-06-06 03:30:19.742172+02]" +88,"[2020-06-04 20:42:10.988308+02, 2020-06-05 05:20:19.516443+02]" +89,"[2020-06-04 12:56:35.898357+02, 2020-06-04 22:00:24.868883+02]" +90,"[2020-06-01 23:45:05.097459+02, 2020-06-02 07:04:31.6975+02]" +91,"[2020-06-04 22:04:31.888732+02, 2020-06-05 22:09:05.888805+02]" +92,"[2020-06-04 00:24:42.24237+02, 2020-06-04 21:40:33.765494+02]" +93,"[2020-06-02 16:43:24.5002+02, 2020-06-03 20:28:47.582924+02]" +94,"[2020-06-03 20:15:19.844183+02, 2020-06-04 15:39:02.342879+02]" +95,"[2020-06-03 16:08:24.154002+02, 2020-06-04 06:59:55.399986+02]" +96,"[2020-06-02 23:32:47.40812+02, 2020-06-03 00:34:59.352015+02]" +97,"[2020-06-03 02:45:15.774443+02, 2020-06-04 04:12:21.903338+02]" +98,"[2020-06-02 15:22:25.505147+02, 2020-06-03 03:35:25.021654+02]" +99,"[2020-06-01 22:03:09.006039+02, 2020-06-02 00:11:16.778186+02]" +100,"[2020-06-03 16:50:50.128806+02, 2020-06-04 12:42:23.99397+02]" diff --git a/berlinmod/data/query_points.csv b/berlinmod/data/query_points.csv new file mode 100644 index 00000000..f26fcf64 --- /dev/null +++ b/berlinmod/data/query_points.csv @@ -0,0 +1,101 @@ +pointid,geom +1,POINT(472288.32404409075 6598955.3536008205) +2,POINT(485421.33002601983 6595656.655677019) +3,POINT(477564.1220671037 6588615.0486065345) +4,POINT(486819.313587249 6606262.7404729985) +5,POINT(486784.092100362 6603149.430840743) +6,POINT(494388.8274541591 6595574.888480721) +7,POINT(486005.7350887863 6593092.247213228) +8,POINT(490797.92784794606 6594362.794402137) +9,POINT(476763.1226711006 6580727.105319336) +10,POINT(488327.58136800706 6592472.0565001555) +11,POINT(485213.385217218 6603202.274533596) +12,POINT(475668.6962293156 6600991.530991405) +13,POINT(486467.4104129533 6604707.9506861195) +14,POINT(485191.9673471893 6594383.122918841) +15,POINT(490340.8388867997 6587740.998979113) +16,POINT(480743.70728678466 6596188.34743634) +17,POINT(488069.37580911204 6598928.116243578) +18,POINT(482409.8038415895 6600987.737279792) +19,POINT(479266.58669955056 6587002.360947727) +20,POINT(492188.61998252815 6586964.118460754) +21,POINT(471042.3472475398 6587352.276505553) +22,POINT(483209.4006120084 6590760.168777742) +23,POINT(471566.2612990092 6599769.005411474) +24,POINT(475366.9981453677 6589081.779659726) +25,POINT(482873.8947987065 6591293.676663365) +26,POINT(498920.5326048625 6583846.9757294785) +27,POINT(472714.688825778 6583816.301888444) +28,POINT(487171.4950602717 6588699.512808007) +29,POINT(495114.88656896004 6589828.516309205) +30,POINT(496382.93802053534 6596708.204547805) +31,POINT(472047.4620618614 6602407.237006391) +32,POINT(470154.76355159783 6586383.157495013) +33,POINT(478455.6242091215 6598638.548493942) +34,POINT(496118.87705642456 6605014.82120193) +35,POINT(480132.80818520923 6602206.067481444) +36,POINT(495671.84024529695 6600262.817589246) +37,POINT(491290.29395572457 6599464.53591192) +38,POINT(477892.124946726 6604412.4951487295) +39,POINT(484809.3622573329 6593125.846692416) +40,POINT(485356.0188807714 6593502.871874817) +41,POINT(488286.0925937884 6599096.763506874) +42,POINT(496370.10288324684 6597070.296912185) +43,POINT(498917.1818881897 6603292.36022281) +44,POINT(485980.8663145432 6595854.014743477) +45,POINT(489918.6485860172 6592588.888444043) +46,POINT(499637.1295629461 6596721.449182641) +47,POINT(477468.1201382434 6590816.36946799) +48,POINT(499130.4143728041 6600684.122511495) +49,POINT(476321.44032748014 6601712.2444410855) +50,POINT(477861.0222809983 6591981.743547052) +51,POINT(470819.530154768 6603292.660274758) +52,POINT(484270.5981857916 6605365.2215687055) +53,POINT(478038.8440355915 6605154.110973328) +54,POINT(481207.0412713644 6603557.610419303) +55,POINT(498144.3463233574 6605511.614538704) +56,POINT(493036.77431483124 6603547.567186334) +57,POINT(479062.3710936903 6591030.848505861) +58,POINT(474788.01434180286 6588136.328801433) +59,POINT(472928.97884555516 6595575.329319583) +60,POINT(488093.13138844736 6598171.133749851) +61,POINT(487139.8803248864 6600047.091996454) +62,POINT(484431.4548499879 6600576.879851658) +63,POINT(485043.8456327399 6595236.5780725125) +64,POINT(489305.2670597971 6589502.371239674) +65,POINT(484520.7108177059 6592757.529150424) +66,POINT(497560.4088024521 6579857.694383519) +67,POINT(487513.83589030826 6597926.87081454) +68,POINT(483413.2488635491 6588308.225682797) +69,POINT(488661.27267360897 6591365.073330278) +70,POINT(483056.1693329316 6596664.502694972) +71,POINT(491034.8379882522 6585584.794992084) +72,POINT(475846.54024780705 6585383.772304282) +73,POINT(488292.2819574765 6583175.487743207) +74,POINT(488036.8927816986 6593401.593248592) +75,POINT(500249.55374154524 6599167.345883156) +76,POINT(492643.23765097884 6601540.508341667) +77,POINT(479270.2379788486 6587404.648856554) +78,POINT(479105.02872256225 6596175.950132492) +79,POINT(497077.4269277474 6594505.941374747) +80,POINT(498632.9387003981 6603075.354933428) +81,POINT(496793.6958096134 6596597.768756016) +82,POINT(475777.789330293 6588797.808805727) +83,POINT(486969.45018448186 6599311.246896206) +84,POINT(479677.5337317629 6584901.559778339) +85,POINT(493825.1500805783 6594448.48129175) +86,POINT(488077.36854855105 6596759.013975384) +87,POINT(477002.1812775791 6589826.29603325) +88,POINT(476060.8191356349 6584853.729273524) +89,POINT(481183.5417268579 6591589.701049651) +90,POINT(472522.58478051616 6581831.179708862) +91,POINT(485575.4518610232 6592356.812614461) +92,POINT(485878.7752095366 6597627.14357898) +93,POINT(492176.2746509992 6587313.768154682) +94,POINT(496613.3916303755 6596635.385891268) +95,POINT(498687.0399729236 6595700.5814140225) +96,POINT(488351.83788505086 6592473.16699513) +97,POINT(495847.58032541233 6602945.595744128) +98,POINT(488333.24753008847 6591267.9803597145) +99,POINT(496657.0066068683 6602154.536120504) +100,POINT(498039.3497796411 6578182.42398841) diff --git a/berlinmod/data/query_regions.csv b/berlinmod/data/query_regions.csv new file mode 100644 index 00000000..b10dd778 --- /dev/null +++ b/berlinmod/data/query_regions.csv @@ -0,0 +1,101 @@ +regionid,geom +1,"POLYGON((4.412249308797437 50.8714669,4.412201722097738 50.87089388675101,4.412059483368486 50.87032714462606,4.41182415100696 50.869772883311434,4.411498303363762 50.86923717596179,4.411085510493858 50.86872589263735,4.410590295042312 50.868244635957936,4.410018082693243 50.86779867968054,4.409375142724891 50.867392910874834,4.408668519322092 50.86703177633228,4.407905954398718 50.86671923379792,4.407095802775646 50.866458708561275,4.406246940643594 50.866253055884115,4.405368668313716 50.86610452967862,4.40447060832145 50.86601475778076,4.403562600000001 50.86598472409122,4.402654591678551 50.86601475778076,4.401756531686283 50.86610452967862,4.400878259356406 50.866253055884115,4.400029397224354 50.866458708561275,4.399219245601282 50.86671923379792,4.398456680677908 50.86703177633228,4.397750057275109 50.867392910874834,4.397107117306757 50.86779867968054,4.396534904957688 50.868244635957936,4.396039689506143 50.86872589263735,4.395626896636239 50.86923717596179,4.39530104899304 50.869772883311434,4.395065716631515 50.87032714462606,4.394923477902262 50.87089388675101,4.394875891202565 50.8714669,4.394923477902262 50.87203990620464,4.395065716631515 50.87260662750442,4.39530104899304 50.873160855123196,4.395626896636239 50.87369651737897,4.396039689506143 50.87420774618237,4.396534904957688 50.8746889412964,4.397107117306757 50.87513483165477,4.397750057275109 50.875540533068765,4.398456680677908 50.87590160169227,4.399219245601282 50.876214082661235,4.400029397224354 50.87647455337686,4.400878259356406 50.87668016096016,4.401756531686283 50.8768286534698,4.402654591678551 50.87691840454249,4.403562600000001 50.876948431187664,4.40447060832145 50.87691840454249,4.405368668313716 50.8768286534698,4.406246940643594 50.87668016096016,4.407095802775646 50.87647455337686,4.407905954398718 50.876214082661235,4.408668519322092 50.87590160169227,4.409375142724891 50.875540533068765,4.410018082693243 50.87513483165477,4.410590295042312 50.8746889412964,4.411085510493858 50.87420774618237,4.411498303363762 50.87369651737897,4.41182415100696 50.873160855123196,4.412059483368486 50.87260662750442,4.412201722097738 50.87203990620464,4.412249308797437 50.8714669))" +2,"POLYGON((4.474579475460425 50.84409819999998,4.474276105372081 50.84288873606425,4.473395691085001 50.841797635986204,4.472024413683809 50.84093171590236,4.470296503354788 50.84037575251492,4.4683811 50.84018417905292,4.466465696645213 50.84037575251492,4.464737786316191 50.84093171590236,4.463366508915 50.841797635986204,4.46248609462792 50.84288873606425,4.462182724539575 50.84409819999998,4.46248609462792 50.845307632583534,4.463366508915 50.84639865058048,4.464737786316191 50.84726446920651,4.466465696645213 50.84782035051283,4.4683811 50.84801189262265,4.470296503354788 50.84782035051283,4.472024413683809 50.84726446920651,4.473395691085001 50.84639865058048,4.474276105372081 50.845307632583534,4.474579475460425 50.84409819999998))" +3,"POLYGON((4.317979802288686 50.85813589999999,4.317975865545138 50.85806632038192,4.317964075375241 50.857997095222615,4.317944491858994 50.857928577279964,4.317917214789509 50.857861115709575,4.317882383164481 50.85779505428549,4.317840174477884 50.85773072964824,4.317790803815512 50.85766846958927,4.317734522758942 50.857608591380455,4.31767161810354 50.85755140015718,4.317602410397008 50.8574971873632,4.317527252305957 50.857446229265356,4.31744652681879 50.85739878554549,4.317360645294085 50.85735509797702,4.317270045364408 50.857315389192614,4.317175188706231 50.857279861549564,4.317076558687344 50.85724869609832,4.316974657903713 50.85722205165977,4.316870005618373 50.85720006401573,4.316763135115384 50.857182845216826,4.31665459098233 50.857170483011465,4.316544926335235 50.85716304039847,4.3164347 50.85716055530605,4.316324473664766 50.85716304039847,4.31621480901767 50.857170483011465,4.316106264884616 50.857182845216826,4.315999394381628 50.85720006401573,4.315894742096288 50.85722205165977,4.315792841312657 50.85724869609832,4.315694211293769 50.857279861549564,4.315599354635593 50.857315389192614,4.315508754705916 50.85735509797702,4.315422873181211 50.85739878554549,4.315342147694044 50.857446229265356,4.315266989602993 50.8574971873632,4.315197781896461 50.85755140015718,4.315134877241058 50.857608591380455,4.315078596184489 50.85766846958927,4.315029225522116 50.85773072964824,4.314987016835519 50.85779505428549,4.314952185210491 50.857861115709575,4.314924908141006 50.857928577279964,4.31490532462476 50.857997095222615,4.314893534454861 50.85806632038192,4.314889597711314 50.85813589999999,4.314893534454861 50.858205479514254,4.31490532462476 50.85827470436422,4.314924908141006 50.85834322179831,4.314952185210491 50.85841068267124,4.314987016835519 50.85847674322321,4.315029225522116 50.85854106683143,4.315078596184489 50.858603325725404,4.315134877241058 50.85866320265695,4.315197781896461 50.8587203925167,4.315266989602993 50.858774603888655,4.315342147694044 50.85882556053493,4.315422873181211 50.85887300280322,4.315508754705916 50.85891668894966,4.315599354635593 50.85895639637055,4.315694211293769 50.85899192273634,4.315792841312657 50.85902308702257,4.315894742096288 50.85904973043208,4.315999394381628 50.85907171720402,4.316106264884616 50.859088935305465,4.31621480901767 50.85910129700227,4.316324473664766 50.85910873930593,4.3164347 50.85911122429452,4.316544926335235 50.85910873930593,4.31665459098233 50.85910129700227,4.316763135115384 50.859088935305465,4.316870005618373 50.85907171720402,4.316974657903713 50.85904973043208,4.317076558687344 50.85902308702257,4.317175188706231 50.85899192273634,4.317270045364408 50.85895639637055,4.317360645294085 50.85891668894966,4.31744652681879 50.85887300280322,4.317527252305957 50.85882556053493,4.317602410397008 50.858774603888655,4.31767161810354 50.8587203925167,4.317734522758942 50.85866320265695,4.317790803815512 50.858603325725404,4.317840174477884 50.85854106683143,4.317882383164481 50.85847674322321,4.317917214789509 50.85841068267124,4.317944491858994 50.85834322179831,4.317964075375241 50.85827470436422,4.317975865545138 50.858205479514254,4.317979802288686 50.85813589999999))" +4,"POLYGON((4.292079156927446 50.871854199999994,4.292067462886613 50.871628775817705,4.29203243083979 50.871404315853134,4.29197421079958 50.87118178129915,4.291893052073133 50.87096212511725,4.291789302194577 50.870746287956216,4.29166340543682 50.870535194123306,4.291515900909104 50.87032974762522,4.291347420248464 50.87013082829577,4.291158684914954 50.869939288027,4.290950503102248 50.8697559471196,4.290723766276828 50.86958159076876,4.290479445360591 50.8694169657,4.290218586573206 50.86926277696982,4.28994230695205 50.86911968494472,4.289651789568877 50.868988302471614,4.289348278463724 50.86886919225164,4.289033073317735 50.868762864428966,4.288707523887739 50.86866977440454,4.288373024226374 50.868590320884515,4.288031006712544 50.868524844171574,4.287682935917749 50.86847362470646,4.287330302334571 50.86843688186607,4.286974615994149 50.86841477302327,4.2866174 50.86840739287234,4.28626018400585 50.86841477302327,4.285904497665429 50.86843688186607,4.285551864082251 50.86847362470646,4.285203793287455 50.868524844171574,4.284861775773625 50.868590320884515,4.284527276112261 50.86866977440454,4.284201726682265 50.868762864428966,4.283886521536276 50.86886919225164,4.283583010431122 50.868988302471614,4.28329249304795 50.86911968494472,4.283016213426794 50.86926277696982,4.282755354639409 50.8694169657,4.282511033723171 50.86958159076876,4.282284296897752 50.8697559471196,4.282076115085045 50.869939288027,4.281887379751535 50.87013082829577,4.281718899090896 50.87032974762522,4.28157139456318 50.870535194123306,4.281445497805422 50.870746287956216,4.281341747926866 50.87096212511725,4.281260589200419 50.87118178129915,4.28120236916021 50.871404315853134,4.281167337113387 50.871628775817705,4.281155643072554 50.871854199999994,4.281167337113387 50.87207962309205,4.28120236916021 50.87230407980455,4.281260589200419 50.872526609000296,4.281341747926866 50.872746257809446,4.281445497805422 50.87296208570938,4.28157139456318 50.87317316855131,4.281718899090896 50.87337860251659,4.281887379751535 50.87357750798582,4.282076115085045 50.873769033304136,4.282284296897752 50.873952358426656,4.282511033723171 50.87412669842826,4.282755354639409 50.874291306863185,4.283016213426794 50.87444547895952,4.28329249304795 50.87458855463538,4.283583010431122 50.87471992132361,4.283886521536276 50.87483901659313,4.284201726682265 50.87494533055561,4.284527276112261 50.875038408047224,4.284861775773625 50.87511785057625,4.285203793287455 50.8751833180281,4.285551864082251 50.87523453012046,4.285904497665429 50.875271267602606,4.28626018400585 50.87529337319335,4.2866174 50.87530075225403,4.286974615994149 50.87529337319335,4.287330302334571 50.875271267602606,4.287682935917749 50.87523453012046,4.288031006712544 50.8751833180281,4.288373024226374 50.87511785057625,4.288707523887739 50.875038408047224,4.289033073317735 50.87494533055561,4.289348278463724 50.87483901659313,4.289651789568877 50.87471992132361,4.28994230695205 50.87458855463538,4.290218586573206 50.87444547895952,4.290479445360591 50.874291306863185,4.290723766276828 50.87412669842826,4.290950503102248 50.873952358426656,4.291158684914954 50.873769033304136,4.291347420248464 50.87357750798582,4.291515900909104 50.87337860251659,4.29166340543682 50.87317316855131,4.291789302194577 50.87296208570938,4.291893052073133 50.872746257809446,4.29197421079958 50.872526609000296,4.29203243083979 50.87230407980455,4.292067462886613 50.87207962309205,4.292079156927446 50.871854199999994))" +5,"POLYGON((4.334583884358573 50.83904230000001,4.334529093620215 50.838779483043346,4.334368455303412 50.838534575295625,4.334112916643988 50.838324267219136,4.333779892179287 50.83816289151358,4.333392076976225 50.83806144621849,4.332975899999999 50.83802684506707,4.332559723023773 50.83806144621849,4.332171907820713 50.83816289151358,4.33183888335601 50.838324267219136,4.331583344696586 50.838534575295625,4.331422706379784 50.838779483043346,4.331367915641425 50.83904230000001,4.331422706379784 50.83930511547648,4.331583344696586 50.839550019180216,4.33183888335601 50.83976032173255,4.332171907820713 50.83992169191393,4.332559723023773 50.84002313316506,4.332975899999999 50.84005773283628,4.333392076976225 50.84002313316506,4.333779892179287 50.83992169191393,4.334112916643988 50.83976032173255,4.334368455303412 50.839550019180216,4.334529093620215 50.83930511547648,4.334583884358573 50.83904230000001))" +6,"POLYGON((4.423918370771307 50.8119924,4.423890872553509 50.81155016905767,4.423808547435772 50.811110660467904,4.423671902979821 50.810676584062264,4.423481781644169 50.81025061625459,4.423239355590068 50.809835383535415,4.42294611945476 50.80943344627232,4.42260388113653 50.80904728291674,4.422214750648413 50.80867927471406,4.421781127109269 50.808331691012235,4.42130568395241 50.80800667525927,4.420791352443001 50.80770623177634,4.420241303605829 50.807432213388424,4.419658928674885 50.8071863099889,4.419047818185278 50.806970038109,4.418411739836389 50.80678473155673,4.417754615262759 50.80663153318311,4.417080495855901 50.80651138782691,4.416393537786122 50.80642503648156,4.415697976378364 50.80637301172028,4.4149981 50.806355634408,4.414298223621636 50.80637301172028,4.413602662213877 50.80642503648156,4.412915704144098 50.80651138782691,4.41224158473724 50.80663153318311,4.41158446016361 50.80678473155673,4.410948381814722 50.806970038109,4.410337271325114 50.8071863099889,4.40975489639417 50.807432213388424,4.409204847556998 50.80770623177634,4.408690516047589 50.80800667525927,4.40821507289073 50.808331691012235,4.407781449351586 50.80867927471406,4.40739231886347 50.80904728291674,4.407050080545239 50.80943344627232,4.406756844409931 50.809835383535415,4.40651441835583 50.81025061625459,4.406324297020178 50.810676584062264,4.406187652564228 50.811110660467904,4.406105327446491 50.81155016905767,4.406077829228693 50.8119924,4.406105327446491 50.812434626755454,4.406187652564228 50.81287412288767,4.406324297020178 50.81330817887185,4.40651441835583 50.813734118796994,4.406756844409931 50.814149316859115,4.407050080545239 50.814551213544014,4.40739231886347 50.814937331399435,4.407781449351586 50.81530529030034,4.40821507289073 50.81565282211275,4.408690516047589 50.815977784666366,4.409204847556998 50.816278174949936,4.40975489639417 50.816552141448454,4.410337271325114 50.81679799554621,4.410948381814722 50.81701422192595,4.41158446016361 50.81719948790002,4.41224158473724 50.817352651616595,4.412915704144098 50.81747276909025,4.413602662213877 50.817559100014144,4.414298223621636 50.81761111231787,4.4149981 50.81762848544327,4.415697976378364 50.81761111231787,4.416393537786122 50.817559100014144,4.417080495855901 50.81747276909025,4.417754615262759 50.817352651616595,4.418411739836389 50.81719948790002,4.419047818185278 50.81701422192595,4.419658928674885 50.81679799554621,4.420241303605829 50.816552141448454,4.420791352443001 50.816278174949936,4.42130568395241 50.815977784666366,4.421781127109269 50.81565282211275,4.422214750648413 50.81530529030034,4.42260388113653 50.814937331399435,4.42294611945476 50.814551213544014,4.423239355590068 50.814149316859115,4.423481781644169 50.813734118796994,4.423671902979821 50.81330817887185,4.423808547435772 50.81287412288767,4.423890872553509 50.812434626755454,4.423918370771307 50.8119924))" +7,"POLYGON((4.44031010601763 50.85534099999999,4.440307845105396 50.855310128614605,4.440301081658002 50.85527952059283,4.440289873378792 50.85524943707228,4.440274315892857 50.85522013471619,4.44025454193118 50.855191863523665,4.440230720198229 50.855164864696604,4.440203053932632 50.85513936858191,4.44017177917321 50.85511559270606,4.440137162745184 50.85509373991925,4.440099499983713 50.85507399666455,4.4400591122142 50.85505653138724,4.44001634401085 50.85504149309755,4.439971560256898 50.855029010099244,4.43992514303154 50.855019188894964,4.43987748835018 50.85501211327748,4.439829002785752 50.85500784361471,4.4397801 50.855006416334675,4.439731197214248 50.85500784361471,4.43968271164982 50.85501211327748,4.439635056968459 50.855019188894964,4.439588639743102 50.855029010099244,4.43954385598915 50.85504149309755,4.439501087785801 50.85505653138724,4.439460700016286 50.85507399666455,4.439423037254816 50.85509373991925,4.43938842082679 50.85511559270606,4.439357146067368 50.85513936858191,4.439329479801771 50.855164864696604,4.43930565806882 50.855191863523665,4.439285884107142 50.85522013471619,4.439270326621207 50.85524943707228,4.439259118341998 50.85527952059283,4.439252354894603 50.855310128614605,4.43925009398237 50.85534099999999,4.439252354894603 50.855371871364945,4.439259118341998 50.85540247932611,4.439270326621207 50.85543256274795,4.439285884107142 50.855461864970565,4.43930565806882 50.855490135999425,4.439329479801771 50.85551713463818,4.439357146067368 50.85554263054635,4.43938842082679 50.85556640620449,4.439423037254816 50.85558825876983,4.439460700016286 50.85560800180682,4.439501087785801 50.85562546687761,4.43954385598915 50.85564050497901,4.439588639743102 50.855652987813635,4.439635056968458 50.855662808884446,4.43968271164982 50.85566988440321,4.439731197214248 50.85567415400538,4.4397801 50.85567558126496,4.439829002785752 50.85567415400538,4.43987748835018 50.85566988440321,4.43992514303154 50.855662808884446,4.439971560256898 50.855652987813635,4.44001634401085 50.85564050497901,4.4400591122142 50.85562546687761,4.440099499983713 50.85560800180682,4.440137162745184 50.85558825876983,4.44017177917321 50.85556640620449,4.440203053932632 50.85554263054635,4.440230720198229 50.85551713463818,4.44025454193118 50.855490135999425,4.440274315892857 50.855461864970565,4.440289873378792 50.85543256274795,4.440301081658002 50.85540247932611,4.440307845105396 50.855371871364945,4.44031010601763 50.85534099999999))" +8,"POLYGON((4.456238438159942 50.910697,4.456211050710393 50.91025748185306,4.456129057214479 50.909820669369694,4.455992963189368 50.909389255758065,4.455803607699983 50.90896590101335,4.45556215818588 50.90855321551342,4.455270103263605 50.908153743918646,4.454929243548871 50.907769949475465,4.454541680555168 50.90740419882048,4.454109803737229 50.907058747379146,4.45363627575925 50.90673572544917,4.45312401607868 50.906437125054836,4.452576182946794 50.906164787653594,4.451996153937022 50.90592039277077,4.451387505121088 50.90570544763314,4.450753989021338 50.9055212778652,4.450099511475196 50.90536901930605,4.449428107554367 50.90524961099741,4.448743916687287 50.90516378938628,4.44805115713817 50.90511208377826,4.4473541 50.90509481306961,4.446657042861831 50.90511208377826,4.445964283312713 50.90516378938628,4.445280092445633 50.90524961099741,4.444608688524804 50.90536901930605,4.443954210978661 50.9055212778652,4.443320694878913 50.90570544763314,4.442712046062979 50.90592039277077,4.442132017053207 50.906164787653594,4.441584183921321 50.906437125054836,4.441071924240752 50.90673572544917,4.440598396262772 50.907058747379146,4.440166519444832 50.90740419882048,4.439778956451129 50.907769949475465,4.439438096736396 50.908153743918646,4.439146041814121 50.90855321551342,4.438904592300017 50.90896590101335,4.438715236810631 50.909389255758065,4.438579142785521 50.909820669369694,4.438497149289607 50.91025748185306,4.438469761840058 50.910697,4.438497149289607 50.91113651399669,4.438579142785521 50.9115733141315,4.438715236810631 50.91200470750034,4.438904592300017 50.91242803460646,4.439146041814121 50.91284068575255,4.439438096736396 50.91324011712416,4.439778956451129 50.913623866465265,4.440166519444832 50.913989568249825,4.440598396262772 50.91433496825574,4.441071924240752 50.91465793745182,4.441584183921321 50.91495648511223,4.442132017053207 50.915228771078056,4.442712046062979 50.91547311709046,4.443320694878913 50.91568801712601,4.443954210978661 50.91587214667077,4.444608688524804 50.91602437087608,4.445280092445633 50.916143751546144,4.445964283312713 50.91622955291448,4.446657042861831 50.916281246173945,4.4473541 50.916298512732354,4.44805115713817 50.916281246173945,4.448743916687287 50.91622955291448,4.449428107554367 50.916143751546144,4.450099511475196 50.91602437087608,4.450753989021338 50.91587214667077,4.451387505121088 50.91568801712601,4.451996153937022 50.91547311709046,4.452576182946794 50.915228771078056,4.45312401607868 50.91495648511223,4.45363627575925 50.91465793745182,4.454109803737229 50.91433496825574,4.454541680555168 50.913989568249825,4.454929243548871 50.913623866465265,4.455270103263605 50.91324011712416,4.45556215818588 50.91284068575255,4.455803607699983 50.91242803460646,4.455992963189368 50.91200470750034,4.456129057214479 50.9115733141315,4.456211050710393 50.91113651399669,4.456238438159942 50.910697))" +9,"POLYGON((4.4925415716087 50.79126409999999,4.492530599090822 50.79104338445024,4.492497724840703 50.79082353892791,4.49244307859799 50.79060543108124,4.492366876026436 50.79038992171257,4.49226941786278 50.790177861380684,4.492151088729867 50.78997008704344,4.492012355618726 50.78976741875375,4.491853766045566 50.7895706564223,4.491675945890979 50.78938057665949,4.491479596929877 50.7891979297093,4.491265494061906 50.78902343648706,4.491034482253272 50.7888577857328,4.490787473202045 50.788701631291744,4.4905254417401 50.788555589532265,4.49024942198591 50.78842023691181,4.489960503263341 50.78829610770038,4.489659825802597 50.78818369187051,4.489348576240249 50.788083433162086,4.489027982936124 50.787995727329836,4.488699311125527 50.787920920580135,4.48836385792594 50.7878593082036,4.488022947217886 50.787811133408724,4.487677924420184 50.78777658636116,4.48733015118019 50.787755803432674,4.486981 50.78774886666237,4.48663184881981 50.787755803432674,4.486284075579816 50.78777658636116,4.485939052782114 50.787811133408724,4.48559814207406 50.7878593082036,4.485262688874473 50.787920920580135,4.484934017063876 50.787995727329836,4.484613423759751 50.788083433162086,4.484302174197404 50.78818369187051,4.484001496736659 50.78829610770038,4.48371257801409 50.78842023691181,4.4834365582599 50.788555589532265,4.483174526797956 50.788701631291744,4.482927517746728 50.7888577857328,4.482696505938094 50.78902343648706,4.482482403070122 50.7891979297093,4.482286054109021 50.78938057665949,4.482108233954434 50.7895706564223,4.481949644381274 50.78976741875375,4.481810911270133 50.78997008704344,4.48169258213722 50.790177861380684,4.481595123973563 50.79038992171257,4.48151892140201 50.79060543108124,4.481464275159297 50.79082353892791,4.481431400909178 50.79104338445024,4.4814204283913 50.79126409999999,4.481431400909178 50.79148481450757,4.481464275159297 50.79170465691982,4.48151892140201 50.79192275963756,4.481595123973563 50.792138261939314,4.48169258213722 50.792350313377746,4.481810911270133 50.79255807713529,4.481949644381274 50.79276073332585,4.482108233954434 50.79295748222957,4.482286054109021 50.79314754744779,4.482482403070122 50.79333017896592,4.482696505938094 50.793504656112006,4.482927517746728 50.79367029039953,4.483174526797956 50.79382642824298,4.4834365582599 50.79397245353574,4.48371257801409 50.79410779008004,4.484001496736659 50.794231903859405,4.484302174197404 50.794344305144705,4.484613423759751 50.794444550425375,4.484934017063876 50.7945322441585,4.485262688874473 50.794607040328486,4.48559814207406 50.79466864381158,4.485939052782114 50.79471681153956,4.486284075579816 50.794751353458174,4.48663184881981 50.79477213327659,4.486981 50.79477906900472,4.48733015118019 50.79477213327659,4.487677924420184 50.794751353458174,4.488022947217886 50.79471681153956,4.48836385792594 50.79466864381158,4.488699311125527 50.794607040328486,4.489027982936124 50.7945322441585,4.489348576240249 50.794444550425375,4.489659825802597 50.794344305144705,4.489960503263341 50.794231903859405,4.49024942198591 50.79410779008004,4.4905254417401 50.79397245353574,4.490787473202045 50.79382642824298,4.491034482253272 50.79367029039953,4.491265494061906 50.793504656112006,4.491479596929877 50.79333017896592,4.491675945890979 50.79314754744779,4.491853766045566 50.79295748222957,4.492012355618726 50.79276073332585,4.492151088729867 50.79255807713529,4.49226941786278 50.792350313377746,4.492366876026436 50.792138261939314,4.49244307859799 50.79192275963756,4.492497724840703 50.79170465691982,4.492530599090822 50.79148481450757,4.4925415716087 50.79126409999999))" +10,"POLYGON((4.28948996365969 50.85755149999999,4.289482824454168 50.857476996504225,4.289461510943297 50.85740357932075,4.289426333926057 50.85733231904506,4.289377806362573 50.857264254824635,4.289316635893995 50.85720037920516,4.289243714523496 50.857141623656055,4.289160105608866 50.85708884498638,4.28906702835635 50.857042812849514,4.288965840041881 50.8570041985185,4.28885801621894 50.856973565096304,4.288745129201665 50.85695135930325,4.288628825136965 50.85693790496205,4.288510799999999 50.8569333982749,4.288392774863034 50.85693790496205,4.288276470798334 50.85695135930325,4.288163583781059 50.856973565096304,4.288055759958119 50.8570041985185,4.28795457164365 50.857042812849514,4.287861494391134 50.85708884498638,4.287777885476503 50.857141623656055,4.287704964106005 50.85720037920516,4.287643793637426 50.857264254824635,4.287595266073942 50.85733231904506,4.287560089056703 50.85740357932075,4.287538775545832 50.857476996504225,4.28753163634031 50.85755149999999,4.287538775545832 50.85762600337673,4.287560089056703 50.857699420210025,4.287595266073942 50.85777067992477,4.287643793637426 50.857838743406035,4.287704964106005 50.85790261815112,4.287777885476503 50.85796137274142,4.287861494391134 50.85801415042361,4.28795457164365 50.85806018160168,4.288055759958119 50.858098795058304,4.288163583781059 50.85812942774136,4.288276470798334 50.858151632973446,4.288392774863034 50.858165086964476,4.288510799999999 50.858169593532594,4.288628825136965 50.858165086964476,4.288745129201665 50.858151632973446,4.28885801621894 50.85812942774136,4.288965840041881 50.858098795058304,4.28906702835635 50.85806018160168,4.289160105608866 50.85801415042361,4.289243714523496 50.85796137274142,4.289316635893995 50.85790261815112,4.289377806362573 50.857838743406035,4.289426333926057 50.85777067992477,4.289461510943297 50.857699420210025,4.289482824454168 50.85762600337673,4.28948996365969 50.85755149999999))" +11,"POLYGON((4.345274547415397 50.83150849999999,4.345266921626678 50.831404321196935,4.345244109321055 50.83130103098114,4.345206305125081 50.831199510597095,4.345153831570824 50.83110062619528,4.34508713634415 50.831005221441934,4.345006788465214 50.830914110320506,4.34491347343379 50.830828070186314,4.344807987380825 50.83074783513345,4.34469123027613 50.83067408973068,4.344564198250152 50.83060746317996,4.344427975095349 50.83054852394711,4.344283723019648 50.830497774910896,4.344132672730893 50.83045564907154,4.343976112936892 50.83042250585561,4.343815379350605 50.830398628048705,4.343651843294317 50.83038421938222,4.3434869 50.830379402794584,4.343321956705682 50.83038421938222,4.343158420649394 50.830398628048705,4.342997687063107 50.83042250585561,4.342841127269106 50.83045564907154,4.342690076980352 50.830497774910896,4.34254582490465 50.83054852394711,4.342409601749847 50.83060746317996,4.34228256972387 50.83067408973068,4.342165812619174 50.83074783513345,4.34206032656621 50.830828070186314,4.341967011534786 50.830914110320506,4.341886663655849 50.831005221441934,4.341819968429175 50.83110062619528,4.341767494874919 50.831199510597095,4.341729690678944 50.83130103098114,4.341706878373322 50.831404321196935,4.341699252584601 50.83150849999999,4.341706878373322 50.83161267857054,4.341729690678944 50.83171596809671,4.341767494874919 50.83181748735747,4.341819968429175 50.83191637024064,4.341886663655849 50.832011773131676,4.341967011534786 50.83210288211054,4.34206032656621 50.83218891989488,4.342165812619174 50.832269152470644,4.34228256972387 50.83234289535339,4.342409601749847 50.83240951942701,4.34254582490465 50.83246845631,4.342690076980352 50.83251920320365,4.342841127269106 50.832561327180706,4.342997687063107 50.83259446887799,4.343158420649394 50.83261834556162,4.343321956705682 50.83263275353847,4.3434869 50.83263756989359,4.343651843294317 50.83263275353847,4.343815379350605 50.83261834556162,4.343976112936892 50.83259446887799,4.344132672730893 50.832561327180706,4.344283723019648 50.83251920320365,4.344427975095349 50.83246845631,4.344564198250152 50.83240951942701,4.34469123027613 50.83234289535339,4.344807987380825 50.832269152470644,4.34491347343379 50.83218891989488,4.345006788465214 50.83210288211054,4.34508713634415 50.832011773131676,4.345153831570824 50.83191637024064,4.345206305125081 50.83181748735747,4.345244109321055 50.83171596809671,4.345266921626678 50.83161267857054,4.345274547415397 50.83150849999999))" +12,"POLYGON((4.482146900971206 50.9118515,4.482110694612106 50.911444996231054,4.482002530850782 50.911043600999236,4.481823769909287 50.910652362279166,4.481576659810181 50.910276200441665,4.481264308106339 50.90991984636126,4.480890642801667 50.90958778190162,4.480460362954175 50.909284183528214,4.4799788795826 50.90901286975862,4.479452247619703 50.908777253112824,4.478887089767976 50.90858029716908,4.478290513215319 50.90842447926699,4.477670020258021 50.908311759328306,4.477033413955038 50.908243555188534,4.476388699999999 50.908220724751054,4.475743986044961 50.908243555188534,4.475107379741979 50.908311759328306,4.47448688678468 50.90842447926699,4.473890310232022 50.90858029716908,4.473325152380297 50.908777253112824,4.472798520417399 50.90901286975862,4.472317037045824 50.909284183528214,4.471886757198333 50.90958778190162,4.47151309189366 50.90991984636126,4.471200740189818 50.910276200441665,4.470953630090713 50.910652362279166,4.470774869149218 50.911043600999236,4.470666705387893 50.911444996231054,4.470630499028793 50.9118515,4.470666705387893 50.91225800021861,4.470774869149218 50.9126593849775,4.470953630090713 50.91305060682716,4.471200740189818 50.913426746242756,4.47151309189366 50.91378307347407,4.471886757198333 50.91411510800378,4.472317037045824 50.9144186748672,4.472798520417399 50.914689957126804,4.473325152380297 50.914925543842664,4.473890310232022 50.91512247293733,4.47448688678468 50.915278268417495,4.475107379741979 50.915390971485785,4.475743986044961 50.915459165152626,4.476388699999999 50.91548199203979,4.477033413955038 50.915459165152626,4.47767002025802 50.915390971485785,4.478290513215319 50.915278268417495,4.478887089767976 50.91512247293733,4.479452247619703 50.914925543842664,4.4799788795826 50.914689957126804,4.480460362954175 50.9144186748672,4.480890642801667 50.91411510800378,4.481264308106339 50.91378307347407,4.481576659810181 50.913426746242756,4.481823769909287 50.91305060682716,4.482002530850782 50.9126593849775,4.482110694612106 50.91225800021861,4.482146900971206 50.9118515))" +13,"POLYGON((4.42630147774911 50.8569656,4.426245019077923 50.856376396562965,4.42607646635892 50.85579577775665,4.425798277470292 50.855232210787314,4.425414509032462 50.85469391449408,4.424930757253424 50.854188739455246,4.424354076323433 50.85372405345077,4.423692875549018 50.85330663395422,4.422956796726367 50.85294256922614,4.422156573542217 50.85263716945533,4.42130387505254 50.85239488924852,4.420411135521424 50.85221926260294,4.419491373101509 50.85211285131423,4.418558 50.85207720757533,4.417624626898491 50.85211285131423,4.416704864478575 50.85221926260294,4.41581212494746 50.85239488924852,4.414959426457783 50.85263716945533,4.414159203273634 50.85294256922614,4.413423124450982 50.85330663395422,4.412761923676567 50.85372405345077,4.412185242746577 50.854188739455246,4.411701490967538 50.85469391449408,4.411317722529709 50.855232210787314,4.411039533641081 50.85579577775665,4.410870980922078 50.856376396562965,4.41081452225089 50.8569656,4.410870980922078 50.85755479599283,4.411039533641081 50.858135392899214,4.411317722529709 50.85869892478558,4.411701490967538 50.85923717485175,4.412185242746577 50.85974229520594,4.412761923676567 50.86020692124629,4.413423124450982 50.8606242789841,4.414159203273634 50.86098828374805,4.414959426457783 50.86129362883422,4.41581212494746 50.86153586281396,4.416704864478575 50.86171145437658,4.417624626898491 50.861817843765344,4.418558 50.861853480060056,4.419491373101509 50.861817843765344,4.420411135521424 50.86171145437658,4.42130387505254 50.86153586281396,4.422156573542217 50.86129362883422,4.422956796726367 50.86098828374805,4.423692875549018 50.8606242789841,4.424354076323433 50.86020692124629,4.424930757253424 50.85974229520594,4.425414509032462 50.85923717485175,4.425798277470292 50.85869892478558,4.42607646635892 50.858135392899214,4.426245019077923 50.85755479599283,4.42630147774911 50.8569656))" +14,"POLYGON((4.347213719258625 50.8268596,4.347133763887719 50.82641135281939,4.346897907071162 50.82598557863857,4.34651797565459 50.82560362844474,4.346013020985684 50.82528465610429,4.34540836360005 50.82504465765277,4.344734323543834 50.82489566890349,4.3440247 50.82484516166637,4.343315076456167 50.82489566890349,4.342641036399951 50.82504465765277,4.342036379014317 50.82528465610429,4.341531424345411 50.82560362844474,4.341151492928839 50.82598557863857,4.340915636112283 50.82641135281939,4.340835680741376 50.8268596,4.340915636112283 50.827307842876756,4.341151492928839 50.82773360499844,4.341531424345411 50.828115537766344,4.342036379014317 50.828434490765446,4.342641036399951 50.828674471791025,4.343315076456167 50.82882344848117,4.3440247 50.82887395141444,4.344734323543834 50.82882344848117,4.34540836360005 50.828674471791025,4.346013020985684 50.828434490765446,4.34651797565459 50.828115537766344,4.346897907071162 50.82773360499844,4.347133763887719 50.827307842876756,4.347213719258625 50.8268596))" +15,"POLYGON((4.365112290141678 50.893302799999994,4.36509986407539 50.89305339183015,4.365062634916531 50.8928049666327,4.365000749591586 50.89255850485198,4.364914452333655 50.89231497919889,4.364804083718592 50.89207535081147,4.3646700793209 50.89184056546086,4.364512967994712 50.89161154981775,4.364333369786658 50.89138920779392,4.364131993488814 50.89117441697349,4.363909633841428 50.89096802514789,4.36366716839644 50.8907708469683,4.36340555405419 50.89058366072871,4.363125823286968 50.89040720529245,4.362829080064315 50.89024217717427,4.36251649549616 50.89008922778953,4.362189303210989 50.889948960881355,4.36184879448727 50.8898219301361,4.361496313157374 50.889708636996275,4.361133250304076 50.88960952867987,4.360761038770589 50.88952499641381,4.360381147505789 50.889455373888495,4.359995075766944 50.889400935939605,4.359604347202826 50.889361897462386,4.359210503840571 50.88933841256276,4.3588151 50.88933057394844,4.358419696159429 50.88933841256276,4.358025852797175 50.889361897462386,4.357635124233056 50.889400935939605,4.35724905249421 50.889455373888495,4.356869161229412 50.88952499641381,4.356496949695924 50.88960952867987,4.356133886842626 50.889708636996275,4.35578140551273 50.8898219301361,4.355440896789012 50.889948960881355,4.35511370450384 50.89008922778953,4.354801119935686 50.89024217717427,4.354504376713032 50.89040720529245,4.35422464594581 50.89058366072871,4.35396303160356 50.8907708469683,4.353720566158572 50.89096802514789,4.353498206511186 50.89117441697349,4.353296830213341 50.89138920779392,4.353117232005287 50.89161154981775,4.352960120679101 50.89184056546086,4.352826116281407 50.89207535081147,4.352715747666346 50.89231497919889,4.352629450408416 50.89255850485198,4.352567565083468 50.8928049666327,4.352530335924611 50.89305339183015,4.352517909858323 50.893302799999994,4.352530335924611 50.89355220683425,4.352567565083468 50.89380062804598,4.352629450408416 50.894047083253724,4.352715747666346 50.89429059985023,4.352826116281407 50.89453021684028,4.352960120679101 50.89476498863248,4.353117232005287 50.89499398876998,4.353296830213341 50.89521631358552,4.353498206511186 50.89543108576637,4.353720566158572 50.89563745781504,4.35396303160356 50.89583461539227,4.35422464594581 50.89602178052896,4.354504376713032 50.89619821469461,4.354801119935686 50.89636322170988,4.35511370450384 50.896516150492275,4.355440896789012 50.896656397623524,4.35578140551273 50.896783409729196,4.356133886842626 50.896896685660735,4.356496949695924 50.89699577847153,4.356869161229412 50.89708029717917,4.35724905249421 50.89714990830713,4.357635124233056 50.89720433719944,4.358025852797175 50.89724336910366,4.358419696159429 50.897266850017566,4.3588151 50.897274687296296,4.359210503840571 50.897266850017566,4.359604347202826 50.89724336910366,4.359995075766944 50.89720433719944,4.360381147505789 50.89714990830713,4.360761038770589 50.89708029717917,4.361133250304076 50.89699577847153,4.361496313157374 50.896896685660735,4.36184879448727 50.896783409729196,4.362189303210989 50.896656397623524,4.36251649549616 50.896516150492275,4.362829080064315 50.89636322170988,4.363125823286968 50.89619821469461,4.36340555405419 50.89602178052896,4.36366716839644 50.89583461539227,4.363909633841428 50.89563745781504,4.364131993488814 50.89543108576637,4.364333369786658 50.89521631358552,4.364512967994712 50.89499398876998,4.3646700793209 50.89476498863248,4.364804083718592 50.89453021684028,4.364914452333655 50.89429059985023,4.365000749591586 50.894047083253724,4.365062634916531 50.89380062804598,4.36509986407539 50.89355220683425,4.365112290141678 50.893302799999994))" +16,"POLYGON((4.46292756559107 50.880385000000004,4.462830904683823 50.8797657806991,4.462544636586545 50.879170349888064,4.462079762421669 50.87862159097254,4.461454147042649 50.87814059444565,4.460691832497651 50.87774584708831,4.459822114107128 50.87745252117429,4.458878414661085 50.877271891049745,4.457897 50.87721089956258,4.456915585338916 50.877271891049745,4.455971885892872 50.87745252117429,4.45510216750235 50.87774584708831,4.454339852957352 50.87814059444565,4.453714237578332 50.87862159097254,4.453249363413455 50.879170349888064,4.452963095316177 50.8797657806991,4.452866434408931 50.880385000000004,4.452963095316177 50.88100421107207,4.453249363413455 50.88159961844937,4.453714237578332 50.882148342293824,4.454339852957352 50.88262929745158,4.45510216750235 50.88302400343976,4.455971885892872 50.88331729428272,4.456915585338916 50.88349790097353,4.457897 50.88355888423186,4.458878414661085 50.88349790097353,4.459822114107128 50.88331729428272,4.460691832497651 50.88302400343976,4.461454147042649 50.88262929745158,4.462079762421669 50.882148342293824,4.462544636586545 50.88159961844937,4.462830904683823 50.88100421107207,4.46292756559107 50.880385000000004))" +17,"POLYGON((4.306579629608065 50.85869160000001,4.306566298000692 50.8584988557306,4.306526404640155 50.858307577573875,4.306460253139016 50.85811922129902,4.306368346950142 50.85793522045503,4.306251385535124 50.85775697545911,4.306110259040955 50.857585842936906,4.30594604152547 50.85742312539551,4.305759982783116 50.85727006130799,4.305553498833272 50.85712781568505,4.305328161143473 50.85699747120542,4.3050856846696 50.85688001997299,4.304827914804032 50.85677635596312,4.30455681333109 50.856687268215836,4.304274443496682 50.85661343482796,4.303982954305743 50.85655541778974,4.303684564167024 50.856513658705595,4.303381544009654 50.85648847543135,4.303076199999999 50.856480059653855,4.302770855990344 50.85648847543135,4.302467835832974 50.856513658705595,4.302169445694255 50.85655541778974,4.301877956503317 50.85661343482796,4.301595586668907 50.856687268215836,4.301324485195966 50.85677635596312,4.301066715330397 50.85688001997299,4.300824238856525 50.85699747120542,4.300598901166725 50.85712781568505,4.300392417216881 50.85727006130799,4.300206358474528 50.85742312539551,4.300042140959043 50.857585842936906,4.299901014464874 50.85775697545911,4.299784053049856 50.85793522045503,4.299692146860982 50.85811922129902,4.299625995359843 50.858307577573875,4.299586101999306 50.8584988557306,4.299572770391933 50.85869160000001,4.299586101999306 50.858884343472724,4.299625995359843 50.859075619263635,4.299692146860982 50.85926397167541,4.299784053049856 50.859447967276466,4.299901014464874 50.859626205808866,4.300042140959043 50.859797330843364,4.300206358474528 50.85996004010037,4.300392417216881 50.860113095358535,4.300598901166725 50.86025533187548,4.300824238856525 50.86038566724908,4.301066715330397 50.860503109652164,4.301324485195966 50.86060676537765,4.301595586668907 50.86069584563723,4.301877956503317 50.860769672561595,4.302169445694255 50.86082768435684,4.302467835832974 50.860869439577925,4.302770855990344 50.860894620486356,4.303076199999999 50.860903035467175,4.303381544009654 50.860894620486356,4.303684564167024 50.860869439577925,4.303982954305743 50.86082768435684,4.304274443496682 50.860769672561595,4.30455681333109 50.86069584563723,4.304827914804032 50.86060676537765,4.3050856846696 50.860503109652164,4.305328161143473 50.86038566724908,4.305553498833272 50.86025533187548,4.305759982783116 50.860113095358535,4.30594604152547 50.85996004010037,4.306110259040955 50.859797330843364,4.306251385535124 50.859626205808866,4.306368346950142 50.859447967276466,4.306460253139016 50.85926397167541,4.306526404640155 50.859075619263635,4.306566298000692 50.858884343472724,4.306579629608065 50.85869160000001))" +18,"POLYGON((4.332284518655757 50.89780710000001,4.332224608434176 50.89747174136926,4.332047881918108 50.897153196784075,4.331763200913015 50.89686743990056,4.331384840513215 50.89662880048532,4.33093177328905 50.896449245717776,4.330426717922984 50.896337779947,4.329894999999999 50.89629999303264,4.329363282077013 50.896337779947,4.328858226710947 50.896449245717776,4.328405159486783 50.89662880048532,4.328026799086983 50.89686743990056,4.327742118081888 50.897153196784075,4.327565391565821 50.89747174136926,4.327505481344241 50.89780710000001,4.327565391565821 50.89814245621562,4.327742118081888 50.89846099403375,4.328026799086983 50.89874674113859,4.328405159486783 50.89898536970034,4.328858226710947 50.8991649146892,4.329363282077013 50.89927637369294,4.329894999999999 50.89931415819217,4.330426717922984 50.89927637369294,4.33093177328905 50.8991649146892,4.331384840513215 50.89898536970034,4.331763200913015 50.89874674113859,4.332047881918108 50.89846099403375,4.332224608434176 50.89814245621562,4.332284518655757 50.89780710000001))" +19,"POLYGON((4.465162408429096 50.87153889999999,4.465150916223269 50.87135431664366,4.465116510459058 50.871170870580876,4.465059403259442 50.870989692837675,4.464979946709295 50.87081190046801,4.464878630684671 50.87063858966589,4.464756079832553 50.87047082900587,4.464613049719698 50.8703096528536,4.464450422174312 50.87015605498695,4.464269199849292 50.87001098246731,4.464070500040534 50.869875329798575,4.463855547798435 50.86974993341032,4.463625668375045 50.86963556649866,4.463382279053452 50.86953293425726,4.463126880409758 50.86944266952745,4.462861047061533 50.86936532889462,4.462586417959764 50.86930138925488,4.462304686284188 50.869251244873205,4.462017589004272 50.8692152049513,4.461726896170212 50.8691934917202,4.4614344 50.86918623906924,4.461141903829788 50.8691934917202,4.460851210995729 50.8692152049513,4.460564113715812 50.869251244873205,4.460282382040236 50.86930138925488,4.460007752938467 50.86936532889462,4.459741919590242 50.86944266952745,4.459486520946548 50.86953293425726,4.459243131624955 50.86963556649866,4.459013252201565 50.86974993341032,4.458798299959466 50.869875329798575,4.458599600150708 50.87001098246731,4.458418377825688 50.87015605498695,4.458255750280302 50.8703096528536,4.458112720167446 50.87047082900587,4.457990169315328 50.87063858966589,4.457888853290705 50.87081190046801,4.457809396740558 50.870989692837675,4.457752289540942 50.871170870580876,4.457717883776731 50.87135431664366,4.457706391570904 50.87153889999999,4.457717883776731 50.87172348262535,4.457752289540942 50.87190692651321,4.457809396740558 50.872088100691094,4.457888853290705 50.87226588819284,4.457990169315328 50.8724391929443,4.458112720167446 50.872606946519916,4.458255750280302 50.87276811472846,4.458418377825688 50.87292170398767,4.458599600150708 50.87306676744813,4.458798299959466 50.87320241082896,4.459013252201565 50.87332779792932,4.459243131624955 50.87344215578178,4.459486520946548 50.87354477941576,4.459741919590242 50.87363503620184,4.460007752938467 50.87371236975026,4.460282382040236 50.87377630333935,4.460564113715812 50.8738264428531,4.460851210995729 50.873862479209684,4.461141903829788 50.87388419026586,4.4614344 50.873891442185844,4.461726896170212 50.87388419026586,4.462017589004272 50.873862479209684,4.462304686284188 50.8738264428531,4.462586417959764 50.87377630333935,4.462861047061533 50.87371236975026,4.463126880409758 50.87363503620184,4.463382279053452 50.87354477941576,4.463625668375045 50.87344215578178,4.463855547798435 50.87332779792932,4.464070500040534 50.87320241082896,4.464269199849292 50.87306676744813,4.464450422174312 50.87292170398767,4.464613049719698 50.87276811472846,4.464756079832553 50.872606946519916,4.464878630684671 50.8724391929443,4.464979946709295 50.87226588819284,4.465059403259442 50.872088100691094,4.465116510459058 50.87190692651321,4.465150916223269 50.87172348262535,4.465162408429096 50.87153889999999))" +20,"POLYGON((4.368438531416666 50.78616280000001,4.366709895726822 50.78352429939611,4.3625366 50.78243135305002,4.358363304273178 50.78352429939611,4.356634668583335 50.78616280000001,4.358363304273178 50.78880115170669,4.3625366 50.789893949155605,4.366709895726822 50.78880115170669,4.368438531416666 50.78616280000001))" +21,"POLYGON((4.37929558664726 50.8281636,4.379284817257766 50.82799913123122,4.379252582655132 50.82783578537738,4.379199103034384 50.82767467827388,4.379124743715554 50.82751691047445,4.379030012648193 50.82736355973235,4.378915556941545 50.82721567363722,4.378782158444142 50.82707426245768,4.378630728402989 50.82694029223853,4.378462301238812 50.82681467820007,4.378278027479928 50.82669827848432,4.378079165902959 50.8265918882911,4.37786707493412 50.82649623444406,4.377643203369783 50.82641197042381,4.377409080479738 50.82633967190213,4.377166305560722 50.826279832807884,4.376916537011599 50.82623286195131,4.376661481004825 50.826199080230225,4.376402879831549 50.82617871843686,4.3761425 50.826171915680526,4.375882120168451 50.82617871843686,4.375623518995175 50.826199080230225,4.3753684629884 50.82623286195131,4.375118694439278 50.826279832807884,4.374875919520261 50.82633967190213,4.374641796630216 50.82641197042381,4.374417925065881 50.82649623444406,4.374205834097041 50.8265918882911,4.374006972520072 50.82669827848432,4.373822698761186 50.82681467820007,4.373654271597011 50.82694029223853,4.373502841555857 50.82707426245768,4.373369443058455 50.82721567363722,4.373254987351808 50.82736355973235,4.373160256284446 50.82751691047445,4.373085896965617 50.82767467827388,4.373032417344867 50.82783578537738,4.373000182742235 50.82799913123122,4.37298941335274 50.8281636,4.373000182742235 50.82832806818934,4.373032417344867 50.82849141232066,4.373085896965617 50.82865251660552,4.373160256284446 50.82881028056712,4.373254987351808 50.82896362655685,4.373369443058455 50.82911150711472,4.373502841555857 50.82925291212315,4.373654271597011 50.82938687570567,4.373822698761186 50.829512482823,4.374006972520072 50.82962887552192,4.374205834097041 50.829735258794024,4.374417925065881 50.82983090600444,4.374641796630216 50.82991516385358,4.374875919520261 50.82998745683798,4.375118694439278 50.83004729117987,4.3753684629884 50.8300942581986,4.375623518995175 50.83012803710107,4.375882120168451 50.83014839717189,4.3761425 50.83015519934879,4.376402879831549 50.83014839717189,4.376661481004825 50.83012803710107,4.376916537011599 50.8300942581986,4.377166305560722 50.83004729117987,4.377409080479738 50.82998745683798,4.377643203369783 50.82991516385358,4.37786707493412 50.82983090600444,4.378079165902959 50.829735258794024,4.378278027479928 50.82962887552192,4.378462301238812 50.829512482823,4.378630728402989 50.82938687570567,4.378782158444142 50.82925291212315,4.378915556941545 50.82911150711472,4.379030012648193 50.82896362655685,4.379124743715554 50.82881028056712,4.379199103034384 50.82865251660552,4.379252582655132 50.82849141232066,4.379284817257766 50.82832806818934,4.37929558664726 50.8281636))" +22,"POLYGON((4.33186075451598 50.8852337,4.331851097738304 50.885101926948195,4.331822209793496 50.88497127776966,4.331774337143318 50.88484286713119,4.331707888220341 50.88471779061009,4.331623429943344 50.884597115346175,4.331521682880571 50.88448187093635,4.331403515102086 50.88437304064912,4.331269934773707 50.88427155303419,4.331122081555701 50.884178273998764,4.330961216879589 50.884093999418255,4.33078871318607 50.88401944834431,4.330606042215835 50.883955256868504,4.330414762453191 50.8839019726937,4.330216505829632 50.88386005045976,4.330012963800765 50.883829847863495,4.329805872915416 50.88381162260577,4.329596999999999 50.88380553019216,4.329388127084582 50.88381162260577,4.329181036199232 50.883829847863495,4.328977494170367 50.88386005045976,4.328779237546808 50.8839019726937,4.328587957784164 50.883955256868504,4.328405286813927 50.88401944834431,4.328232783120409 50.884093999418255,4.328071918444297 50.884178273998764,4.32792406522629 50.88427155303419,4.327790484897912 50.88437304064912,4.327672317119426 50.88448187093635,4.327570570056654 50.884597115346175,4.327486111779658 50.88471779061009,4.32741966285668 50.88484286713119,4.327371790206501 50.88497127776966,4.327342902261694 50.885101926948195,4.327333245484018 50.8852337,4.327342902261694 50.88536547267908,4.327371790206501 50.88549612075216,4.32741966285668 50.885624529590054,4.327486111779658 50.88574960367681,4.327570570056654 50.88587027595548,4.327672317119426 50.885985516930845,4.327790484897912 50.886094343451326,4.32792406522629 50.88619582709553,4.328071918444297 50.88628910209144,4.328232783120409 50.88637337270121,4.328405286813927 50.886447920008415,4.328587957784164 50.88651210804976,4.328779237546808 50.88656538923932,4.328977494170367 50.88660730903891,4.329181036199232 50.8866375098346,4.329388127084582 50.88665573398686,4.329596999999999 50.88666182602775,4.329805872915416 50.88665573398686,4.330012963800765 50.8866375098346,4.330216505829632 50.88660730903891,4.330414762453191 50.88656538923932,4.330606042215835 50.88651210804976,4.33078871318607 50.886447920008415,4.330961216879589 50.88637337270121,4.331122081555701 50.88628910209144,4.331269934773707 50.88619582709553,4.331403515102086 50.886094343451326,4.331521682880571 50.885985516930845,4.331623429943344 50.88587027595548,4.331707888220341 50.88574960367681,4.331774337143318 50.885624529590054,4.331822209793496 50.88549612075216,4.331851097738304 50.88536547267908,4.33186075451598 50.8852337))" +23,"POLYGON((4.43751232142453 50.8971073,4.437453116618842 50.89672816528382,4.437277777409259 50.8963635975911,4.436993041983272 50.896027607554,4.436609852563623 50.89573310782986,4.436142934904811 50.89549141676098,4.435610232390617 50.89531182328268,4.435032216479914 50.895201229820245,4.4344311 50.89516388691862,4.433829983520085 50.895201229820245,4.433251967609384 50.89531182328268,4.432719265095189 50.89549141676098,4.432252347436378 50.89573310782986,4.431869158016728 50.896027607554,4.431584422590742 50.8963635975911,4.431409083381158 50.89672816528382,4.43134987857547 50.8971073,4.431409083381158 50.897486431629446,4.431584422590742 50.89785099053192,4.431869158016728 50.898186967413494,4.432252347436378 50.898481451619624,4.432719265095189 50.8987231271705,4.433251967609384 50.89890270749328,4.433829983520085 50.89901329216547,4.4344311 50.89905063198037,4.435032216479914 50.89901329216547,4.435610232390617 50.89890270749328,4.436142934904811 50.8987231271705,4.436609852563623 50.898481451619624,4.436993041983272 50.898186967413494,4.437277777409259 50.89785099053192,4.437453116618842 50.897486431629446,4.43751232142453 50.8971073))" +24,"POLYGON((4.478686289416032 50.8386188,4.478673157510893 50.83841829602951,4.478633851499706 50.83821916085176,4.478568639882382 50.8380227547881,4.478477968120391 50.837830419533965,4.478362455593808 50.837643468992475,4.478222891370316 50.837463180297654,4.478060228815081 50.83729078508822,4.477875579078289 50.8371274610921,4.477670203504877 50.83697432407863,4.47744550501826 50.83683242023412,4.477203018536941 50.83670271901235,4.476944400489467 50.83658610650938,4.476671417499337 50.83648337940775,4.476385934317174 50.83639523953149,4.47608990108259 50.836322289049505,4.475785340002749 50.8362650263598,4.475474331538648 50.836223842682934,4.475159000193455 50.83619901938801,4.474841500000001 50.83619072606952,4.474523999806546 50.83619901938801,4.474208668461352 50.836223842682934,4.473897659997252 50.8362650263598,4.473593098917411 50.836322289049505,4.473297065682826 50.83639523953149,4.473011582500663 50.83648337940775,4.472738599510533 50.83658610650938,4.472479981463059 50.83670271901235,4.472237494981741 50.83683242023412,4.472012796495124 50.83697432407863,4.471807420921711 50.8371274610921,4.47162277118492 50.83729078508822,4.471460108629684 50.837463180297654,4.471320544406192 50.837643468992475,4.47120503187961 50.837830419533965,4.471114360117618 50.8380227547881,4.471049148500295 50.83821916085176,4.471009842489107 50.83841829602951,4.470996710583969 50.8386188,4.471009842489107 50.838819303109,4.471049148500295 50.83901843572576,4.471114360117618 50.8392148375988,4.47120503187961 50.839407167147,4.471320544406192 50.83959411062287,4.471460108629684 50.83977439108512,4.47162277118492 50.83994677711959,4.471807420921711 50.84011009124865,4.472012796495124 50.84026321797207,4.472237494981741 50.84040511138426,4.472479981463059 50.84053480231597,4.472738599510533 50.84065140495187,4.473011582500663 50.84075412287856,4.473297065682826 50.840842254522244,4.473593098917411 50.8409151979386,4.473897659997252 50.84097245492237,4.474208668461352 50.841013634408625,4.474523999806546 50.84103845514255,4.474841500000001 50.84104674759955,4.475159000193455 50.84103845514255,4.475474331538648 50.841013634408625,4.475785340002749 50.84097245492237,4.47608990108259 50.8409151979386,4.476385934317174 50.840842254522244,4.476671417499337 50.84075412287856,4.476944400489467 50.84065140495187,4.477203018536941 50.84053480231597,4.47744550501826 50.84040511138426,4.477670203504877 50.84026321797207,4.477875579078289 50.84011009124865,4.478060228815081 50.83994677711959,4.478222891370316 50.83977439108512,4.478362455593808 50.83959411062287,4.478477968120391 50.839407167147,4.478568639882382 50.8392148375988,4.478633851499706 50.83901843572576,4.478673157510893 50.838819303109,4.478686289416032 50.8386188))" +25,"POLYGON((4.336501411923514 50.8550784,4.33641680482212 50.85439974250972,4.336165066825568 50.85373778630544,4.335752396558803 50.8531088319956,4.335188955333368 50.85252836815788,4.334488616942189 50.852010689798874,4.333668626040745 50.85156854616194,4.332749173526421 50.851212826574866,4.331752899371613 50.85095229209501,4.330704335152451 50.850793359581125,4.3296293 50.85073994352909,4.328554264847548 50.850793359581125,4.327505700628387 50.85095229209501,4.326509426473576 50.851212826574866,4.325589973959254 50.85156854616194,4.324769983057809 50.852010689798874,4.324069644666629 50.85252836815788,4.323506203441195 50.8531088319956,4.323093533174432 50.85373778630544,4.32284179517788 50.85439974250972,4.322757188076485 50.8550784,4.32284179517788 50.85575704761479,4.323093533174432 50.856418975159315,4.323506203441195 50.85704788483053,4.324069644666629 50.857628292420294,4.324769983057809 50.858145908427964,4.325589973959254 50.85858798971356,4.326509426473576 50.85894365305267,4.327505700628387 50.85920414289391,4.328554264847548 50.85936304674803,4.3296293 50.859416452924584,4.330704335152451 50.85936304674803,4.331752899371613 50.85920414289391,4.332749173526421 50.85894365305267,4.333668626040745 50.85858798971356,4.334488616942189 50.858145908427964,4.335188955333368 50.857628292420294,4.335752396558803 50.85704788483053,4.336165066825568 50.856418975159315,4.33641680482212 50.85575704761479,4.336501411923514 50.8550784))" +26,"POLYGON((4.369350538640028 50.8502027,4.369281832846664 50.849540883976495,4.369076891041746 50.84889038265842,4.368739219836376 50.84826232700616,4.368274596878498 50.847667464343616,4.36769097199574 50.84711597439226,4.366998331171657 50.84661729499413,4.366208525682785 50.8461799605121,4.365335069320014 50.84581145568053,4.364392907163879 50.84551808741536,4.363398159870088 50.84530487678539,4.362367847840635 50.845175473001234,4.3613196 50.84513209090004,4.360271352159364 50.845175473001234,4.359241040129911 50.84530487678539,4.35824629283612 50.84551808741536,4.357304130679985 50.84581145568053,4.356430674317214 50.8461799605121,4.355640868828342 50.84661729499413,4.354948228004258 50.84711597439226,4.354364603121501 50.847667464343616,4.353899980163623 50.84826232700616,4.353562308958254 50.84889038265842,4.353357367153334 50.849540883976495,4.35328866135997 50.8502027,4.353357367153334 50.85086450663371,4.353562308958254 50.85151498042229,4.353899980163623 50.85214299228144,4.354364603121501 50.85273779787172,4.354948228004258 50.853289221361,4.355640868828342 50.853787829436534,4.356430674317214 50.854225092595975,4.357304130679985 50.85459353096546,4.35824629283612 50.854886842158365,4.359241040129911 50.85510000899524,4.360271352159364 50.855229385249906,4.3613196 50.8552727579613,4.362367847840635 50.855229385249906,4.363398159870088 50.85510000899524,4.364392907163879 50.854886842158365,4.365335069320014 50.85459353096546,4.366208525682785 50.854225092595975,4.366998331171657 50.853787829436534,4.36769097199574 50.853289221361,4.368274596878498 50.85273779787172,4.368739219836376 50.85214299228144,4.369076891041746 50.85151498042229,4.369281832846664 50.85086450663371,4.369350538640028 50.8502027))" +27,"POLYGON((4.362283288455858 50.906497,4.362226781290108 50.90599878667509,4.362058410115796 50.90551071036649,4.36178160248449 50.90504270737238,4.361401993401316 50.90460430562818,4.360927310612506 50.904204430685084,4.360367217290766 50.903851223934005,4.359733115320952 50.90355187678218,4.359037913190571 50.90331248416461,4.3582957632102 50.90313792038056,4.357521773413255 50.9030317397894,4.3567317 50.902996104393814,4.355941626586745 50.9030317397894,4.355167636789799 50.90313792038056,4.354425486809428 50.90331248416461,4.353730284679048 50.90355187678218,4.353096182709235 50.903851223934005,4.352536089387494 50.904204430685084,4.352061406598684 50.90460430562818,4.35168179751551 50.90504270737238,4.351404989884204 50.90551071036649,4.351236618709892 50.90599878667509,4.351180111544141 50.906497,4.351236618709892 50.90699520799296,4.351404989884204 50.907483268737685,4.35168179751551 50.9079512471969,4.352061406598684 50.90838961742283,4.352536089387494 50.90878945641774,4.353096182709235 50.90914262570298,4.353730284679048 50.90944193690661,4.354425486809428 50.90968129800592,4.355167636789799 50.909855837255066,4.355941626586745 50.909962002282356,4.3567317 50.909997632346,4.357521773413255 50.909962002282356,4.3582957632102 50.909855837255066,4.359037913190571 50.90968129800592,4.359733115320952 50.90944193690661,4.360367217290766 50.90914262570298,4.360927310612506 50.90878945641774,4.361401993401316 50.90838961742283,4.36178160248449 50.9079512471969,4.362058410115796 50.907483268737685,4.362226781290108 50.90699520799296,4.362283288455858 50.906497))" +28,"POLYGON((4.357051500011033 50.90037389999999,4.357034097373014 50.90005261653675,4.356981970598092 50.899732828843945,4.356895362725351 50.89941602796555,4.356774677560676 50.899103691049476,4.356620477794013 50.89879727445895,4.356433482375858 50.89849820698039,4.356214563165169 50.898207883159245,4.355964740864367 50.897927656795176,4.355685180260336 50.89765883462663,4.355377184793666 50.897402670234726,4.3550421904814 50.89716035819454,4.354681759221658 50.89693302850138,4.354297571511357 50.89672174129806,4.35389141861095 50.89652748192778,4.353465194192747 50.89635115633583,4.353020885511739 50.896193586841584,4.352560564140098 50.896055508300584,4.35208637630855 50.89593756467469,4.351600532899663 50.895840306026344,4.351105299139682 50.89576418595111,4.350602984037005 50.89570955946026,4.35009592961652 50.895676681323685,4.3495865 50.89566570488058,4.34907707038348 50.895676681323685,4.348570015962995 50.89570955946026,4.348067700860318 50.89576418595111,4.347572467100336 50.895840306026344,4.347086623691449 50.89593756467469,4.346612435859902 50.896055508300584,4.346152114488261 50.896193586841584,4.345707805807253 50.89635115633583,4.34528158138905 50.89652748192778,4.344875428488643 50.89672174129806,4.344491240778342 50.89693302850138,4.3441308095186 50.89716035819454,4.343795815206334 50.897402670234726,4.343487819739663 50.89765883462663,4.343208259135633 50.897927656795176,4.34295843683483 50.898207883159245,4.342739517624142 50.89849820698039,4.342552522205986 50.89879727445895,4.342398322439324 50.899103691049476,4.342277637274649 50.89941602796555,4.342191029401908 50.899732828843945,4.342138902626985 50.90005261653675,4.342121499988966 50.90037389999999,4.342138902626985 50.90069518124638,4.342191029401908 50.9010149623299,4.342277637274649 50.901331752329696,4.342398322439324 50.90164407430053,4.342552522205986 50.90195047215753,4.342739517624142 50.90224951746329,4.34295843683483 50.90253981608539,4.343208259135633 50.902820014693575,4.343487819739663 50.903088807066425,4.343795815206334 50.903344940177874,4.3441308095186 50.90358722003554,4.344491240778342 50.90381451724362,4.344875428488643 50.90402577226441,4.34528158138905 50.90422000035424,4.345707805807253 50.904396296150495,4.346152114488261 50.904553837888855,4.346612435859902 50.90469189123081,4.347086623691449 50.90480981268391,4.347572467100336 50.90490705259874,4.348067700860318 50.90498315772872,4.348570015962995 50.90503777334098,4.34907707038348 50.90507064486826,4.3495865 50.90508161909452,4.35009592961652 50.90507064486826,4.350602984037005 50.90503777334098,4.351105299139682 50.90498315772872,4.351600532899663 50.90490705259874,4.35208637630855 50.90480981268391,4.352560564140098 50.90469189123081,4.353020885511739 50.904553837888855,4.353465194192747 50.904396296150495,4.35389141861095 50.90422000035424,4.354297571511357 50.90402577226441,4.354681759221658 50.90381451724362,4.3550421904814 50.90358722003554,4.355377184793666 50.903344940177874,4.355685180260336 50.903088807066425,4.355964740864367 50.902820014693575,4.356214563165169 50.90253981608539,4.356433482375858 50.90224951746329,4.356620477794013 50.90195047215753,4.356774677560676 50.90164407430053,4.356895362725351 50.901331752329696,4.356981970598092 50.9010149623299,4.357034097373014 50.90069518124638,4.357051500011033 50.90037389999999))" +29,"POLYGON((4.381241852718415 50.799741,4.381151605143594 50.79901623973046,4.380883084613938 50.79830931463524,4.380442902996057 50.79763763275125,4.37984189902226 50.797017734976876,4.379094871405002 50.796464887597935,4.378220214443461 50.79599270615147,4.377239465094849 50.79561281991163,4.376176772663052 50.795334585283726,4.375058304162613 50.795164855189,4.3739116 50.79510781014069,4.372764895837384 50.795164855189,4.371646427336946 50.795334585283726,4.370583734905149 50.79561281991163,4.369602985556538 50.79599270615147,4.368728328594996 50.796464887597935,4.367981300977738 50.797017734976876,4.367380297003942 50.79763763275125,4.36694011538606 50.79830931463524,4.366671594856404 50.79901623973046,4.366581347281584 50.799741,4.366671594856404 50.80046574902894,4.36694011538606 50.801172641502724,4.367380297003942 50.80184427257764,4.367981300977738 50.802464106328834,4.368728328594996 50.803016882737545,4.369602985556538 50.80348899321376,4.370583734905149 50.80386881543044,4.371646427336946 50.804146999249255,4.372764895837384 50.80431669672256,4.3739116 50.80437373053029,4.375058304162613 50.80431669672256,4.376176772663052 50.804146999249255,4.377239465094849 50.80386881543044,4.378220214443461 50.80348899321376,4.379094871405002 50.803016882737545,4.37984189902226 50.802464106328834,4.380442902996057 50.80184427257764,4.380883084613938 50.801172641502724,4.381151605143594 50.80046574902894,4.381241852718415 50.799741))" +30,"POLYGON((4.402973360410832 50.79609030000001,4.402970170333735 50.79603641078792,4.40296061794265 50.79598282288455,4.402944756658423 50.795929835976736,4.402922675183789 50.7958777463913,4.402894497007311 50.79582684543783,4.402860379712781 50.79577741777943,4.402820514097952 50.79572973984073,4.402775123107511 50.79568407826184,4.40272446058629 50.795640688407126,4.402668809859657 50.79559981293689,4.402608482149049 50.79556168045024,4.402543814831497 50.795526504206464,4.402475169552872 50.79549448093228,4.402402930205416 50.79546578972144,4.402327500780863 50.79544059103317,4.402249303111152 50.795419025794466,4.402168774509373 50.79540121461199,4.402086365324132 50.79538725709748,4.402002536421021 50.795377231310454,4.40191775660527 50.795371193321756,4.401832499999999 50.79536917689979,4.40174724339473 50.795371193321756,4.401662463578979 50.795377231310454,4.401578634675867 50.79538725709748,4.401496225490627 50.79540121461199,4.401415696888848 50.795419025794466,4.401337499219137 50.79544059103317,4.401262069794584 50.79546578972144,4.401189830447127 50.79549448093228,4.401121185168502 50.795526504206464,4.40105651785095 50.79556168045024,4.400996190140343 50.79559981293689,4.40094053941371 50.795640688407126,4.400889876892489 50.79568407826184,4.400844485902048 50.79572973984073,4.400804620287218 50.79577741777943,4.400770502992689 50.79582684543783,4.40074232481621 50.7958777463913,4.400720243341577 50.795929835976736,4.40070438205735 50.79598282288455,4.400694829666264 50.79603641078792,4.400691639589168 50.79609030000001,4.400694829666264 50.79614418914996,4.40070438205735 50.79619777686831,4.400720243341577 50.796250763472344,4.40074232481621 50.79630285264203,4.400770502992689 50.79635375307708,4.400804620287218 50.79640318012595,4.400844485902048 50.79645085737764,4.400889876892489 50.79649651820738,4.40094053941371 50.796539907267544,4.400996190140343 50.79658078191557,4.40105651785095 50.79661891357073,4.401121185168502 50.796654088992305,4.401189830447127 50.79668611147194,4.401262069794584 50.79671480193362,4.401337499219137 50.79673999993489,4.401415696888848 50.796761564564065,4.401496225490627 50.796779375228105,4.401578634675867 50.79679333232689,4.401662463578979 50.79680335781013,4.40174724339473 50.79680939561381,4.401832499999999 50.796811411973636,4.40191775660527 50.79680939561381,4.402002536421021 50.79680335781013,4.402086365324132 50.79679333232689,4.402168774509373 50.796779375228105,4.402249303111152 50.796761564564065,4.402327500780863 50.79673999993489,4.402402930205416 50.79671480193362,4.402475169552872 50.79668611147194,4.402543814831497 50.796654088992305,4.402608482149049 50.79661891357073,4.402668809859657 50.79658078191557,4.40272446058629 50.796539907267544,4.402775123107511 50.79649651820738,4.402820514097952 50.79645085737764,4.402860379712781 50.79640318012595,4.402894497007311 50.79635375307708,4.402922675183789 50.79630285264203,4.402944756658423 50.796250763472344,4.40296061794265 50.79619777686831,4.402970170333735 50.79614418914996,4.402973360410832 50.79609030000001))" +31,"POLYGON((4.370289459696218 50.8370606,4.37027225337487 50.83677019185753,4.370220730635554 50.836481406003145,4.370135179614329 50.83619585748955,4.370016078747208 50.835915143293825,4.36986409409455 50.83564083338486,4.369680075616185 50.83537446194118,4.369465052418089 50.83511751876837,4.369220226997206 50.83487144096418,4.368946968516601 50.83463760487793,4.368646805148542 50.834417318409365,4.36832141552834 50.834211813690004,4.36797261936674 50.834022240188055,4.367602367273366 50.833849658275675,4.367212729848108 50.83369503329441,4.366805886101504 50.83355923015231,4.366384111268814 50.833443008482945,4.365949764085989 50.833347018393454,4.365505273598665 50.833271796825585,4.365053125577948 50.83321776455014,4.364595848618978 50.833185223811476,4.364136 50.83317435663565,4.363676151381021 50.833185223811476,4.363218874422051 50.83321776455014,4.362766726401335 50.833271796825585,4.36232223591401 50.833347018393454,4.361887888731186 50.833443008482945,4.361466113898494 50.83355923015231,4.36105927015189 50.83369503329441,4.360669632726633 50.833849658275675,4.360299380633259 50.834022240188055,4.35995058447166 50.834211813690004,4.359625194851457 50.834417318409365,4.359325031483398 50.83463760487793,4.359051773002792 50.83487144096418,4.358806947581911 50.83511751876837,4.358591924383814 50.83537446194118,4.35840790590545 50.83564083338486,4.358255921252792 50.835915143293825,4.35813682038567 50.83619585748955,4.358051269364445 50.836481406003145,4.357999746625129 50.83677019185753,4.357982540303781 50.8370606,4.357999746625129 50.83735100633531,4.358051269364445 50.83763978680854,4.35813682038567 50.83792532648723,4.358255921252792 50.83820602859164,4.35840790590545 50.83848032342297,4.358591924383814 50.838746677139525,4.358806947581911 50.8390036003317,4.359051773002792 50.83924965634808,4.359325031483398 50.839483469326055,4.359625194851457 50.839703731882075,4.35995058447166 50.8399092124188,4.360299380633259 50.84009876200821,4.360669632726633 50.84027132081232,4.36105927015189 50.84042592400578,4.361466113898494 50.84056170716724,4.361887888731186 50.84067791110949,4.36232223591401 50.840773886121355,4.362766726401335 50.84084909559788,4.363218874422051 50.84090311903842,4.363676151381021 50.84093565439595,4.364136 50.8409465197646,4.364595848618978 50.84093565439595,4.365053125577948 50.84090311903842,4.365505273598665 50.84084909559788,4.365949764085989 50.840773886121355,4.366384111268814 50.84067791110949,4.366805886101504 50.84056170716724,4.367212729848108 50.84042592400578,4.367602367273366 50.84027132081232,4.36797261936674 50.84009876200821,4.36832141552834 50.8399092124188,4.368646805148542 50.839703731882075,4.368946968516601 50.839483469326055,4.369220226997206 50.83924965634808,4.369465052418089 50.8390036003317,4.369680075616185 50.838746677139525,4.36986409409455 50.83848032342297,4.370016078747208 50.83820602859164,4.370135179614329 50.83792532648723,4.370220730635554 50.83763978680854,4.37027225337487 50.83735100633531,4.370289459696218 50.8370606))" +32,"POLYGON((4.391457845495052 50.889676599999994,4.3914199225593 50.889281114228545,4.391306706753845 50.88889139224546,4.391119849020068 50.88851311728985,4.390862074164495 50.888151805806814,4.39053714112498 50.88781272698525,4.390149788156923 50.88750082589483,4.389705663738843 50.887220651344556,4.389211244204834 50.88697628951663,4.388673739305039 50.88677130434553,4.388100987071254 50.886608685513536,4.387501339520771 50.886490804823325,4.386883540865167 50.88641938158524,4.3862566 50.88639545752597,4.385629659134834 50.88641938158524,4.38501186047923 50.886490804823325,4.384412212928747 50.886608685513536,4.383839460694961 50.88677130434553,4.383301955795168 50.88697628951663,4.382807536261158 50.887220651344556,4.382363411843078 50.88750082589483,4.38197605887502 50.88781272698525,4.381651125835504 50.888151805806814,4.381393350979932 50.88851311728985,4.381206493246156 50.88889139224546,4.3810932774407 50.889281114228545,4.381055354504948 50.889676599999994,4.3810932774407 50.89007208241364,4.381206493246156 50.89046179451841,4.381393350979932 50.89084005364931,4.381651125835504 50.891201344280915,4.38197605887502 50.891540398436135,4.382363411843078 50.89185227247881,4.382807536261158 50.892132419171865,4.383301955795168 50.89237675395205,4.383839460694961 50.8925817144568,4.384412212928747 50.89274431243736,4.38501186047923 50.89286217730286,4.385629659134834 50.89293359066264,4.3862566 50.8929575113641,4.386883540865167 50.89293359066264,4.387501339520771 50.89286217730286,4.388100987071254 50.89274431243736,4.388673739305039 50.8925817144568,4.389211244204834 50.89237675395205,4.389705663738843 50.892132419171865,4.390149788156923 50.89185227247881,4.39053714112498 50.891540398436135,4.390862074164495 50.891201344280915,4.391119849020068 50.89084005364931,4.391306706753845 50.89046179451841,4.3914199225593 50.89007208241364,4.391457845495052 50.889676599999994))" +33,"POLYGON((4.37481254404376 50.82026549999999,4.374811959079156 50.8202537405865,4.37481020649393 50.8202420275791,4.374807293204739 50.820230407203724,4.374803230709002 50.82021892532079,4.374798035039534 50.82020762724414,4.374791726701269 50.820196557562284,4.374784330590336 50.82018575996237,4.374775875895806 50.8201752770578,4.374766395984495 50.820165150220035,4.374755928269283 50.82015541941532,4.374744514061459 50.820146123046946,4.374732198407687 50.82013729780372,4.374719029912225 50.82012897851512,4.37470506054511 50.82012119801383,4.374690345437052 50.82011398700623,4.374674942661858 50.82010737395115,4.374658913007246 50.82010138494754,4.37464231973494 50.82009604363152,4.374625228331005 50.82009137108304,4.374607706247404 50.82008738574274,4.374589822635794 50.82008410333907,4.374571648074621 50.82008153682637,4.374553254290576 50.820079696333586,4.374534713875519 50.82007858912439,4.3745161 50.82007821956851,4.374497486124481 50.82007858912439,4.374478945709424 50.820079696333586,4.374460551925379 50.82008153682637,4.374442377364207 50.82008410333907,4.374424493752597 50.82008738574274,4.374406971668996 50.82009137108304,4.37438988026506 50.82009604363152,4.374373286992753 50.82010138494754,4.374357257338142 50.82010737395115,4.374341854562949 50.82011398700623,4.37432713945489 50.82012119801383,4.374313170087775 50.82012897851512,4.374300001592314 50.82013729780372,4.374287685938541 50.820146123046946,4.374276271730717 50.82015541941532,4.374265804015505 50.820165150220035,4.374256324104195 50.8201752770578,4.374247869409665 50.82018575996237,4.374240473298731 50.820196557562284,4.374234164960466 50.82020762724414,4.374228969290998 50.82021892532079,4.37422490679526 50.820230407203724,4.37422199350607 50.8202420275791,4.374220240920844 50.8202537405865,4.374219655956241 50.82026549999999,4.374220240920844 50.82027725941052,4.37422199350607 50.82028897240909,4.37422490679526 50.82030059276988,4.374228969290998 50.820312074632746,4.374234164960466 50.820323372684115,4.374240473298731 50.82033444233592,4.374247869409665 50.82034523990144,4.374256324104195 50.820355722767864,4.374265804015505 50.8203658495643,4.374276271730717 50.82037558032516,4.374287685938541 50.82038487664785,4.374300001592314 50.82039370184429,4.374313170087775 50.820402021085734,4.37432713945489 50.82040980154022,4.374341854562949 50.82041701250215,4.374357257338142 50.82042362551337,4.374373286992753 50.82042961447564,4.37438988026506 50.82043495575351,4.374406971668996 50.82043962826761,4.374424493752597 50.820443613577865,4.374442377364207 50.820446895956245,4.374460551925379 50.82044946244888,4.374478945709424 50.82045130292708,4.374497486124481 50.82045241012743,4.3745161 50.82045277968036,4.374534713875519 50.82045241012743,4.374553254290576 50.82045130292708,4.374571648074621 50.82044946244888,4.374589822635794 50.820446895956245,4.374607706247404 50.820443613577865,4.374625228331005 50.82043962826761,4.37464231973494 50.82043495575351,4.374658913007246 50.82042961447564,4.374674942661858 50.82042362551337,4.374690345437052 50.82041701250215,4.37470506054511 50.82040980154022,4.374719029912225 50.820402021085734,4.374732198407687 50.82039370184429,4.374744514061459 50.82038487664785,4.374755928269283 50.82037558032516,4.374766395984495 50.8203658495643,4.374775875895806 50.820355722767864,4.374784330590336 50.82034523990144,4.374791726701269 50.82033444233592,4.374798035039534 50.820323372684115,4.374803230709002 50.820312074632746,4.374807293204739 50.82030059276988,4.37481020649393 50.82028897240909,4.374811959079156 50.82027725941052,4.37481254404376 50.82026549999999))" +34,"POLYGON((4.349595765948376 50.90142970000001,4.348856425569615 50.90030401158253,4.3470715 50.89983772820188,4.345286574430385 50.90030401158253,4.344547234051624 50.90142970000001,4.345286574430385 50.90255536120257,4.3470715 50.903021617368296,4.348856425569615 50.90255536120257,4.349595765948376 50.90142970000001))" +35,"POLYGON((4.408875289058726 50.8669689,4.408844706828978 50.86657601438048,4.408753254663328 50.86618690920079,4.408601813296122 50.86580533189771,4.408391841190513 50.86543495749855,4.40812536049266 50.86507935321984,4.407804937557357 50.86474194410118,4.407433658232632 50.86442598000582,4.407015098141344 50.8641345043062,4.406553288245982 50.86387032455676,4.406052676028284 50.86363598543698,4.405518082657575 50.86343374422618,4.40495465656025 50.86326554904679,4.404367823837627 50.86313302008633,4.40376323600962 50.86303743397976,4.403146715587515 50.862979711502845,4.4025242 50.86296040869578,4.401901684412485 50.862979711502845,4.40128516399038 50.86303743397976,4.400680576162374 50.86313302008633,4.400093743439752 50.86326554904679,4.399530317342426 50.86343374422618,4.398995723971716 50.86363598543698,4.39849511175402 50.86387032455676,4.398033301858656 50.8641345043062,4.397614741767368 50.86442598000582,4.397243462442643 50.86474194410118,4.396923039507341 50.86507935321984,4.396656558809488 50.86543495749855,4.396446586703879 50.86580533189771,4.396295145336673 50.86618690920079,4.396203693171023 50.86657601438048,4.396173110941276 50.8669689,4.396203693171023 50.8673617823084,4.396295145336673 50.86775087768194,4.396446586703879 50.868132439060716,4.396656558809488 50.86850279202936,4.396923039507341 50.86885837019492,4.397243462442643 50.8691957495213,4.397614741767368 50.869511681290156,4.398033301858656 50.86980312337133,4.39849511175402 50.870067269502314,4.398995723971716 50.87030157629558,4.399530317342426 50.8705037877141,4.400093743439752 50.87067195678034,4.400680576162374 50.87080446431029,4.40128516399038 50.87090003449255,4.401901684412485 50.870957747163324,4.4025242 50.87097704665926,4.403146715587515 50.870957747163324,4.40376323600962 50.87090003449255,4.404367823837627 50.87080446431029,4.40495465656025 50.87067195678034,4.405518082657575 50.8705037877141,4.406052676028284 50.87030157629558,4.406553288245982 50.870067269502314,4.407015098141344 50.86980312337133,4.407433658232632 50.869511681290156,4.407804937557357 50.8691957495213,4.40812536049266 50.86885837019492,4.408391841190513 50.86850279202936,4.408601813296122 50.868132439060716,4.408753254663328 50.86775087768194,4.408844706828978 50.8673617823084,4.408875289058726 50.8669689))" +36,"POLYGON((4.30522471408942 50.7666451,4.2984604 50.76236660876242,4.29169608591058 50.7666451,4.2984604 50.770923200003935,4.30522471408942 50.7666451))" +37,"POLYGON((4.425555937434296 50.8505241,4.424694221213652 50.848493667783565,4.422339968717147 50.847007232208774,4.419124 50.84646314718645,4.415908031282852 50.847007232208774,4.413553778786348 50.848493667783565,4.412692062565704 50.8505241,4.413553778786348 50.85255444383708,4.415908031282852 50.85404070265314,4.419124 50.85458469929609,4.422339968717147 50.85404070265314,4.424694221213652 50.85255444383708,4.425555937434296 50.8505241))" +38,"POLYGON((4.426602272211565 50.88546829999999,4.426555900124326 50.88498465667141,4.426417460072058 50.88450806104002,4.426188970822466 50.88404546326483,4.42587376426332 50.88360360957814,4.425476436816036 50.88318894388033,4.4250027824095 50.88280751373385,4.424459707991536 50.8824648821295,4.423855132810054 50.882166046314325,4.423197872932586 50.881915364867766,4.422497512688164 50.88171649409268,4.421764264906227 50.881572334651466,4.421008821990565 50.88148498922846,4.420242199999999 50.88145573183816,4.419475578009433 50.88148498922846,4.41872013509377 50.881572334651466,4.417986887311834 50.88171649409268,4.417286527067413 50.881915364867766,4.416629267189944 50.882166046314325,4.416024692008461 50.8824648821295,4.415481617590498 50.88280751373385,4.415007963183961 50.88318894388033,4.414610635736678 50.88360360957814,4.414295429177533 50.88404546326483,4.41406693992794 50.88450806104002,4.413928499875673 50.88498465667141,4.413882127788432 50.88546829999999,4.413928499875673 50.88595193830771,4.41406693992794 50.88642851916825,4.414295429177533 50.88689109328106,4.414610635736678 50.887332915789,4.415007963183961 50.88774754460372,4.415481617590498 50.88812893430623,4.416024692008461 50.88847152425622,4.416629267189944 50.88877031962743,4.417286527067413 50.88902096419087,4.417986887311834 50.88921980378722,4.41872013509377 50.88936393956607,4.419475578009433 50.889451270218224,4.420242199999999 50.88948052258765,4.421008821990565 50.889451270218224,4.421764264906227 50.88936393956607,4.422497512688164 50.88921980378722,4.423197872932586 50.88902096419087,4.423855132810054 50.88877031962743,4.424459707991536 50.88847152425622,4.4250027824095 50.88812893430623,4.425476436816036 50.88774754460372,4.42587376426332 50.887332915789,4.426188970822466 50.88689109328106,4.426417460072058 50.88642851916825,4.426555900124326 50.88595193830771,4.426602272211565 50.88546829999999))" +39,"POLYGON((4.453141633337011 50.8569168,4.452808259882935 50.856131401765104,4.451897466668505 50.85555644196731,4.4506533 50.85534599030305,4.449409133331494 50.85555644196731,4.448498340117065 50.856131401765104,4.448164966662989 50.8569168,4.448498340117065 50.8577021850078,4.449409133331494 50.85827711835143,4.4506533 50.858487556788596,4.451897466668505 50.85827711835143,4.452808259882935 50.8577021850078,4.453141633337011 50.8569168))" +40,"POLYGON((4.33858597329452 50.88378800000001,4.338277327204638 50.882558548692316,4.337381601364739 50.88144941680978,4.33598647566092 50.88056918597315,4.33422851471748 50.88000403422216,4.3322798 50.87980929461247,4.330331085282521 50.88000403422216,4.328573124339082 50.88056918597315,4.32717799863526 50.88144941680978,4.326282272795361 50.882558548692316,4.325973626705482 50.88378800000001,4.326282272795361 50.88501741886484,4.32717799863526 50.88612646581089,4.328573124339082 50.887006591660246,4.330331085282521 50.887571658474734,4.3322798 50.88776636564158,4.33422851471748 50.887571658474734,4.33598647566092 50.887006591660246,4.337381601364739 50.88612646581089,4.338277327204638 50.88501741886484,4.33858597329452 50.88378800000001))" +41,"POLYGON((4.323021425399034 50.83645479999999,4.322955288083173 50.835924082910616,4.322758504655803 50.835406428023134,4.322435920577993 50.83491458236044,4.321995478940333 50.834460657794445,4.321448024877685 50.83405583271366,4.320807038525968 50.83371007665098,4.320088303096471 50.833431904664046,4.319309516240816 50.833228167529626,4.318489854276034 50.833103882931496,4.3176495 50.83306211181054,4.316809145723966 50.833103882931496,4.315989483759183 50.833228167529626,4.315210696903528 50.833431904664046,4.314491961474031 50.83371007665098,4.313850975122313 50.83405583271366,4.313303521059665 50.834460657794445,4.312863079422006 50.83491458236044,4.312540495344196 50.835406428023134,4.312343711916826 50.835924082910616,4.312277574600965 50.83645479999999,4.312343711916826 50.83698551105411,4.312540495344196 50.83750314842658,4.312863079422006 50.837994966808985,4.313303521059665 50.83844885699983,4.313850975122313 50.83885364397548,4.314491961474031 50.839199361933005,4.315210696903528 50.839477499544785,4.315989483759183 50.83968120939891,4.316809145723966 50.839805476482034,4.3176495 50.839847241567725,4.318489854276034 50.839805476482034,4.319309516240816 50.83968120939891,4.320088303096471 50.839477499544785,4.320807038525968 50.839199361933005,4.321448024877685 50.83885364397548,4.321995478940333 50.83844885699983,4.322435920577993 50.837994966808985,4.322758504655803 50.83750314842658,4.322955288083173 50.83698551105411,4.323021425399034 50.83645479999999))" +42,"POLYGON((4.366246141643327 50.83446750000001,4.366233381334941 50.83425211983213,4.366195171770601 50.83403794317191,4.366131726633693 50.8338261678069,4.366043400735156 50.833617978111505,4.365930688029243 50.83341453842265,4.365794218851127 50.833216986527034,4.365634756391809 50.83302642729663,4.365453192430045 50.83284392650794,4.365250542345159 50.83267050487975,4.365027939438627 50.83250713236257,4.3647866285962 50.8323547227119,4.364527959325991 50.832214128375696,4.364253378211488 50.83208613572464,4.363964420821663 50.83197146065195,4.363662703123451 50.83187074456751,4.363349912444609 50.83178455080852,4.363027798037493 50.83171336148709,4.362698161296528 50.8316575747922,4.362362845684084 50.83161750276137,4.362023726421082 50.831593369534346,4.3616827 50.83158531009868,4.361341673578918 50.831593369534346,4.361002554315916 50.83161750276137,4.360667238703472 50.8316575747922,4.360337601962507 50.83171336148709,4.36001548755539 50.83178455080852,4.359702696876548 50.83187074456751,4.359400979178336 50.83197146065195,4.359112021788511 50.83208613572464,4.358837440674008 50.832214128375696,4.3585787714038 50.8323547227119,4.358337460561373 50.83250713236257,4.358114857654841 50.83267050487975,4.357912207569954 50.83284392650794,4.357730643608191 50.83302642729663,4.357571181148873 50.833216986527034,4.357434711970757 50.83341453842265,4.357321999264845 50.833617978111505,4.357233673366308 50.8338261678069,4.357170228229399 50.83403794317191,4.357132018665059 50.83425211983213,4.357119258356673 50.83446750000001,4.357132018665059 50.83468287917396,4.357170228229399 50.834897052874595,4.357233673366308 50.83510882338051,4.357321999264845 50.8353170064258,4.357434711970757 50.835520437822105,4.357571181148873 50.83571797996798,4.357730643608191 50.835908528209266,4.357912207569954 50.83609101701489,4.358114857654841 50.83626442593376,4.358337460561373 50.8364277852993,4.3585787714038 50.83658018164978,4.358837440674008 50.83672076283434,4.359112021788511 50.8368487427761,4.359400979178336 50.836963405865696,4.359702696876548 50.837064110961,4.36001548755539 50.83715029497025,4.360337601962507 50.83722147599915,4.360667238703472 50.83727725604395,4.361002554315916 50.837317323215665,4.361341673578918 50.83734145348313,4.3616827 50.83734951192487,4.362023726421082 50.83734145348313,4.362362845684084 50.837317323215665,4.362698161296528 50.83727725604395,4.363027798037493 50.83722147599915,4.363349912444609 50.83715029497025,4.363662703123451 50.837064110961,4.363964420821663 50.836963405865696,4.364253378211488 50.8368487427761,4.364527959325991 50.83672076283434,4.3647866285962 50.83658018164978,4.365027939438627 50.8364277852993,4.365250542345159 50.83626442593376,4.365453192430045 50.83609101701489,4.365634756391809 50.835908528209266,4.365794218851127 50.83571797996798,4.365930688029243 50.835520437822105,4.366043400735156 50.8353170064258,4.366131726633693 50.83510882338051,4.366195171770601 50.834897052874595,4.366233381334941 50.83468287917396,4.366246141643327 50.83446750000001))" +43,"POLYGON((4.4100412698001 50.817120300000006,4.410023947650883 50.81691147377338,4.409972170988321 50.81670493457212,4.409886507088366 50.816502945328125,4.409767894502631 50.816307719150956,4.409617632775426 50.81612139507732,4.409437368205681 50.81594601463111,4.409229075809743 50.81578349945084,4.40899503768269 50.8156356302299,4.408737817995219 50.81550402720071,4.40846023490005 50.815390132376656,4.408165329655664 50.81529519374689,4.40785633330563 50.81522025159728,4.407536631278623 50.81516612710756,4.40720972629695 50.81513341335011,4.4068792 50.815122468788886,4.40654867370305 50.81513341335011,4.406221768721377 50.81516612710756,4.405902066694368 50.81522025159728,4.405593070344335 50.81529519374689,4.405298165099949 50.815390132376656,4.405020582004781 50.81550402720071,4.404763362317309 50.8156356302299,4.404529324190257 50.81578349945084,4.404321031794319 50.81594601463111,4.404140767224573 50.81612139507732,4.403990505497369 50.816307719150956,4.403871892911634 50.816502945328125,4.403786229011678 50.81670493457212,4.403734452349117 50.81691147377338,4.403717130199899 50.817120300000006,4.403734452349117 50.81732912529284,4.403786229011678 50.81753566173357,4.403871892911634 50.81773764651095,4.403990505497369 50.81793286671061,4.404140767224573 50.8181191835571,4.404321031794319 50.81829455584238,4.404529324190257 50.818457062284615,4.404763362317309 50.818604922572305,4.405020582004781 50.818736516863474,4.405298165099949 50.81885040352661,4.405593070344335 50.81894533492921,4.405902066694368 50.819020271101316,4.406221768721377 50.81907439112441,4.40654867370305 50.81910710212134,4.4068792 50.81911804574878,4.40720972629695 50.81910710212134,4.407536631278623 50.81907439112441,4.40785633330563 50.819020271101316,4.408165329655664 50.81894533492921,4.40846023490005 50.81885040352661,4.408737817995219 50.818736516863474,4.40899503768269 50.818604922572305,4.409229075809743 50.818457062284615,4.409437368205681 50.81829455584238,4.409617632775426 50.8181191835571,4.409767894502631 50.81793286671061,4.409886507088366 50.81773764651095,4.409972170988321 50.81753566173357,4.410023947650883 50.81732912529284,4.4100412698001 50.817120300000006))" +44,"POLYGON((4.363010293747843 50.83132439999999,4.361947327509339 50.82970352835863,4.359381099999999 50.82903212485683,4.35681487249066 50.82970352835863,4.355751906252157 50.83132439999999,4.35681487249066 50.83294521535829,4.359381099999999 50.833616562577035,4.361947327509339 50.83294521535829,4.363010293747843 50.83132439999999))" +45,"POLYGON((4.283700893033229 50.8866479,4.283569604779051 50.88570120696627,4.283179729143686 50.88478326035107,4.282543112301024 50.883921953996776,4.28167909753169 50.88314346208994,4.280613937487235 50.88247144341001,4.279379996516615 50.88192632190284,4.278014767291816 50.88152466550644,4.276559731611995 50.88127868217616,4.2750591 50.88119584849021,4.273558468388004 50.88127868217616,4.272103432708184 50.88152466550644,4.270738203483385 50.88192632190284,4.269504262512765 50.88247144341001,4.26843910246831 50.88314346208994,4.267575087698975 50.883921953996776,4.266938470856315 50.88478326035107,4.266548595220948 50.88570120696627,4.26641730696677 50.8866479,4.266548595220948 50.88759457379564,4.266938470856315 50.88851246501701,4.267575087698975 50.88937368650303,4.26843910246831 50.890152074303515,4.269504262512765 50.89082398219577,4.270738203483385 50.8913689995966,4.272103432708184 50.891770571124724,4.273558468388004 50.892016499061164,4.2750591 50.892099313509036,4.276559731611995 50.892016499061164,4.278014767291816 50.891770571124724,4.279379996516615 50.8913689995966,4.280613937487235 50.89082398219577,4.28167909753169 50.890152074303515,4.282543112301024 50.88937368650303,4.283179729143686 50.88851246501701,4.283569604779051 50.88759457379564,4.283700893033229 50.8866479))" +46,"POLYGON((4.43050286390525 50.890009000000006,4.43049440850779 50.889839276735216,4.430469075685001 50.88967022267586,4.43042696541396 50.88950250501196,4.430368243884669 50.88933678566654,4.430293142844178 50.889173718682905,4.430201958681982 50.88901394764315,4.430095051260311 50.88885810312769,4.429972842493918 50.888706800226075,4.429835814684971 50.88856063610884,4.429684508619631 50.88842018767003,4.429519521433812 50.88828600924956,4.42934150425656 50.88815863044479,4.429151159640347 50.888038554019424,4.428949238788414 50.88792625391849,4.428736538590112 50.887822173396934,4.428513898475951 50.887726723269445,4.428282197104747 50.88764028028819,4.428042348895959 50.88756318565517,4.42779530042089 50.88749574367477,4.427542026667005 50.88743822055211,4.427283527190102 50.887390843341834,4.427020822169518 50.88735379905132,4.426754948381952 50.88732723390225,4.426486955109776 50.88731125275313,4.4262179 50.88730591868515,4.425948844890225 50.88731125275313,4.425680851618049 50.88732723390225,4.425414977830481 50.88735379905132,4.425152272809898 50.887390843341834,4.424893773332995 50.88743822055211,4.42464049957911 50.88749574367477,4.424393451104041 50.88756318565517,4.424153602895252 50.88764028028819,4.423921901524049 50.887726723269445,4.423699261409889 50.887822173396934,4.423486561211586 50.88792625391849,4.423284640359652 50.888038554019424,4.423094295743439 50.88815863044479,4.422916278566189 50.88828600924956,4.42275129138037 50.88842018767003,4.42259998531503 50.88856063610884,4.422462957506083 50.888706800226075,4.422340748739689 50.88885810312769,4.422233841318019 50.88901394764315,4.422142657155823 50.889173718682905,4.422067556115331 50.88933678566654,4.422008834586041 50.88950250501196,4.421966724314999 50.88967022267586,4.42194139149221 50.889839276735216,4.42193293609475 50.890009000000006,4.42194139149221 50.890178722646354,4.421966724314999 50.890347774860196,4.422008834586041 50.890515489480585,4.422067556115331 50.89068120463252,4.422142657155823 50.89084426633881,4.422233841318019 50.89100403110059,4.422340748739689 50.89115986843645,4.422462957506083 50.89131116337007,4.42259998531503 50.89145731885658,4.42275129138037 50.89159775813805,4.422916278566189 50.89173192701895,4.423094295743439 50.89185929605241,4.423284640359652 50.891979362628796,4.423486561211586 50.89209165295842,4.423699261409889 50.89219572394041,4.423921901524049 50.892291164910546,4.424153602895252 50.89237759926108,4.424393451104041 50.89245468592611,4.42464049957911 50.892522120726916,4.424893773332995 50.892579637571586,4.425152272809898 50.89262700950452,4.425414977830481 50.89266404960155,4.425680851618049 50.89269061170712,4.425948844890225 50.89270659101073,4.4262179 50.89271192446027,4.426486955109776 50.89270659101073,4.426754948381952 50.89269061170712,4.427020822169518 50.89266404960155,4.427283527190102 50.89262700950452,4.427542026667005 50.892579637571586,4.42779530042089 50.892522120726916,4.428042348895959 50.89245468592611,4.428282197104747 50.89237759926108,4.428513898475951 50.892291164910546,4.428736538590112 50.89219572394041,4.428949238788414 50.89209165295842,4.429151159640347 50.891979362628796,4.42934150425656 50.89185929605241,4.429519521433812 50.89173192701895,4.429684508619631 50.89159775813805,4.429835814684971 50.89145731885658,4.429972842493918 50.89131116337007,4.430095051260311 50.89115986843645,4.430201958681982 50.89100403110059,4.430293142844178 50.89084426633881,4.430368243884669 50.89068120463252,4.43042696541396 50.890515489480585,4.430469075685001 50.890347774860196,4.43049440850779 50.890178722646354,4.43050286390525 50.890009000000006))" +47,"POLYGON((4.414779544646626 50.8793284,4.41477580144002 50.879271296960255,4.414764597390102 50.87921458392292,4.414746009031894 50.879158648297675,4.414720163342728 50.87910387218502,4.41468723687487 50.8790506297661,4.414647454549482 50.87899928474646,4.414601088120186 50.87895018787153,4.414548454316708 50.87890367453034,4.414489912681296 50.87886006246436,4.41442586311268 50.87881964959679,4.414356743134361 50.878782711997154,4.414283024905876 50.878749501995244,4.414205211997474 50.87872024645724,4.414123835950222 50.87869514523577,4.414039452645037 50.87867436980445,4.413952638505455 50.8786580620864,4.413863986560081 50.87864633348463,4.413774102391591 50.87863926412085,4.4136836 50.87863690228813,4.413593097608407 50.87863926412085,4.413503213439918 50.87864633348463,4.413414561494543 50.8786580620864,4.413327747354963 50.87867436980445,4.413243364049777 50.87869514523577,4.413161988002525 50.87872024645724,4.413084175094123 50.878749501995244,4.413010456865638 50.878782711997154,4.412941336887317 50.87881964959679,4.412877287318703 50.87886006246436,4.412818745683291 50.87890367453034,4.412766111879812 50.87895018787153,4.412719745450516 50.87899928474646,4.412679963125129 50.8790506297661,4.412647036657272 50.87910387218502,4.412621190968106 50.879158648297675,4.412602602609896 50.87921458392292,4.412591398559979 50.879271296960255,4.412587655353374 50.8793284,4.412591398559979 50.879385502969754,4.412602602609896 50.87944221579906,4.412621190968106 50.87949815108392,4.412647036657272 50.8795529267331,4.412679963125129 50.87960616857811,4.412719745450516 50.87965751292901,4.412766111879812 50.87970660905869,4.412818745683291 50.8797531215984,4.412877287318703 50.87979673282854,4.412941336887317 50.879837144848715,4.413010456865638 50.87987408161252,4.413084175094123 50.87990729081295,4.413161988002525 50.87993654560569,4.413243364049777 50.87996164615844,4.413327747354963 50.879982421015846,4.413414561494543 50.87999872827041,4.413503213439918 50.880010456531785,4.413593097608407 50.88001752568754,4.4136836 50.8800198874503,4.413774102391591 50.88001752568754,4.413863986560081 50.880010456531785,4.413952638505455 50.87999872827041,4.414039452645037 50.879982421015846,4.414123835950222 50.87996164615844,4.414205211997474 50.87993654560569,4.414283024905876 50.87990729081295,4.414356743134361 50.87987408161252,4.41442586311268 50.879837144848715,4.414489912681296 50.87979673282854,4.414548454316708 50.8797531215984,4.414601088120186 50.87970660905869,4.414647454549482 50.87965751292901,4.41468723687487 50.87960616857811,4.414720163342728 50.8795529267331,4.414746009031894 50.87949815108392,4.414764597390102 50.87944221579906,4.41477580144002 50.879385502969754,4.414779544646626 50.8793284))" +48,"POLYGON((4.426147235625696 50.8516921,4.426112729024779 50.851359723202414,4.426009799639535 50.85103303115595,4.425840208620283 50.850717613829296,4.425606857716382 50.850418868382235,4.425313739626496 50.85014190679959,4.424965869682409 50.849891468398624,4.424569200035314 50.84967183870891,4.424130517812848 50.84948677611443,4.423657328989464 50.84933944751532,4.423157729957125 50.84923237411212,4.422640268993787 50.84916738824234,4.4221138 50.84914560200942,4.421587331006213 50.84916738824234,4.421069870042874 50.84923237411212,4.420570271010536 50.84933944751532,4.420097082187152 50.84948677611443,4.419658399964686 50.84967183870891,4.41926173031759 50.849891468398624,4.418913860373504 50.85014190679959,4.418620742283618 50.850418868382235,4.418387391379717 50.850717613829296,4.418217800360465 50.85103303115595,4.418114870975221 50.851359723202414,4.418080364374303 50.8516921,4.418114870975221 50.85202447442911,4.418217800360465 50.85235115953155,4.418387391379717 50.852666565811866,4.418620742283618 50.85296529686303,4.418913860373504 50.853242241681336,4.41926173031759 50.853492662091924,4.419658399964686 50.853712273791274,4.420097082187152 50.853897319621396,4.420570271010536 50.85404463382462,4.421069870042874 50.854151696181496,4.421587331006213 50.854216675107246,4.4221138 50.85423845897167,4.422640268993787 50.854216675107246,4.423157729957125 50.854151696181496,4.423657328989464 50.85404463382462,4.424130517812848 50.853897319621396,4.424569200035314 50.853712273791274,4.424965869682409 50.853492662091924,4.425313739626496 50.853242241681336,4.425606857716382 50.85296529686303,4.425840208620283 50.852666565811866,4.426009799639535 50.85235115953155,4.426112729024779 50.85202447442911,4.426147235625696 50.8516921))" +49,"POLYGON((4.343484239834728 50.853132899999984,4.343473815057686 50.85299893497777,4.34344264112286 50.852866259732714,4.343391018252285 50.852736152016355,4.343319443602423 50.85260986486378,4.343228606476282 50.85248861452515,4.343119381685041 50.852373568751226,4.342992821123146 50.852265835545545,4.342850143637998 50.852166452491836,4.342692723291771 50.85207637675954,4.342522076128454 50.85199647588343,4.342339845573516 50.851927519406715,4.342147786606818 50.85187017146781,4.3419477488612 50.85182498440242,4.341741658809503 50.85179239342254,4.341531501211586 50.85177271242378,4.3413193 50.85176613096133,4.341107098788414 50.85177271242378,4.340896941190498 50.85179239342254,4.340690851138801 50.85182498440242,4.340490813393183 50.85187017146781,4.340298754426485 50.851927519406715,4.340116523871547 50.85199647588343,4.33994587670823 50.85207637675954,4.339788456362003 50.852166452491836,4.339645778876854 50.852265835545545,4.33951921831496 50.852373568751226,4.339409993523719 50.85248861452515,4.339319156397577 50.85260986486378,4.339247581747716 50.852736152016355,4.33919595887714 50.852866259732714,4.339164784942315 50.85299893497777,4.339154360165272 50.853132899999984,4.339164784942315 50.85326686463742,4.33919595887714 50.85339953874292,4.339247581747716 50.85352964460874,4.339319156397577 50.8536559292709,4.339409993523719 50.85377717657495,4.33951921831496 50.853892218886756,4.339645778876854 50.85399994833582,4.339788456362003 50.85409932748276,4.33994587670823 50.854189399308304,4.340116523871547 50.854269296427795,4.340298754426485 50.85433824944238,4.340490813393183 50.85439559434671,4.340690851138801 50.85444077892169,4.340896941190498 50.854473368051025,4.341107098788414 50.854493047910225,4.3413193 50.8544996289879,4.341531501211586 50.854493047910225,4.341741658809503 50.854473368051025,4.3419477488612 50.85444077892169,4.342147786606818 50.85439559434671,4.342339845573516 50.85433824944238,4.342522076128454 50.854269296427795,4.342692723291771 50.854189399308304,4.342850143637998 50.85409932748276,4.342992821123146 50.85399994833582,4.343119381685041 50.853892218886756,4.343228606476282 50.85377717657495,4.343319443602423 50.8536559292709,4.343391018252285 50.85352964460874,4.34344264112286 50.85339953874292,4.343473815057686 50.85326686463742,4.343484239834728 50.853132899999984))" +50,"POLYGON((4.335839561136479 50.783463999999995,4.335717123732326 50.78287599828458,4.335358155426622 50.78232806125858,4.334787119316179 50.78185753194297,4.33404293056824 50.78149647888995,4.333176304416148 50.78126951002535,4.3322463 50.78119209492042,4.331316295583854 50.78126951002535,4.330449669431761 50.78149647888995,4.329705480683822 50.78185753194297,4.32913444457338 50.78232806125858,4.328775476267676 50.78287599828458,4.328653038863523 50.783463999999995,4.328775476267676 50.78405199432095,4.32913444457338 50.78459991114491,4.329705480683822 50.78507041286401,4.330449669431761 50.785431438320515,4.331316295583854 50.78565838698308,4.3322463 50.785735794693544,4.333176304416148 50.78565838698308,4.33404293056824 50.785431438320515,4.334787119316179 50.78507041286401,4.335358155426622 50.78459991114491,4.335717123732326 50.78405199432095,4.335839561136479 50.783463999999995))" +51,"POLYGON((4.281987124316082 50.8109604,4.280397937167428 50.8085360387749,4.2765613 50.807531798622804,4.272724662832571 50.8085360387749,4.271135475683918 50.8109604,4.272724662832571 50.81338463540427,4.2765613 50.814388749735556,4.280397937167428 50.81338463540427,4.281987124316082 50.8109604))" +52,"POLYGON((4.508424701696852 50.85474030000001,4.508379723161668 50.85419849870001,4.508245280350358 50.85366262729738,4.508022846246496 50.85313855721599,4.507714857884673 50.85263203077031,4.507324689649829 50.85214859822979,4.506856616306798 50.85169355698015,4.506315766165072 50.851271893449294,4.505708064891986 50.85088822843554,4.505040170589858 50.850546766439024,4.504319400848426 50.85025124955328,4.50355365257181 50.85000491642391,4.502751315458371 50.84981046672591,4.501921180081424 50.84967003155063,4.501072341577875 50.84958515002822,4.5002141 50.84955675244309,4.499355858422125 50.84958515002822,4.498507019918576 50.84967003155063,4.497676884541629 50.84981046672591,4.496874547428189 50.85000491642391,4.496108799151574 50.85025124955328,4.495388029410142 50.850546766439024,4.494720135108014 50.85088822843554,4.494112433834928 50.851271893449294,4.493571583693202 50.85169355698015,4.493103510350171 50.85214859822979,4.492713342115328 50.85263203077031,4.492405353753504 50.85313855721599,4.492182919649642 50.85366262729738,4.492048476838333 50.85419849870001,4.492003498303148 50.85474030000001,4.492048476838333 50.85528209500592,4.492182919649642 50.85581794780135,4.492405353753504 50.85634198777566,4.492713342115328 50.85684847393022,4.493103510350171 50.85733185775648,4.493571583693202 50.85778684399775,4.494112433834928 50.85820844863028,4.494720135108014 50.85859205342989,4.495388029410142 50.85893345652808,4.496108799151574 50.85922891840546,4.496874547428189 50.859475202820555,4.497676884541629 50.859669612227435,4.498507019918576 50.859810017295636,4.499355858422125 50.85989488021086,4.5002141 50.859923271501884,4.501072341577875 50.85989488021086,4.501921180081424 50.859810017295636,4.502751315458371 50.859669612227435,4.50355365257181 50.859475202820555,4.504319400848426 50.85922891840546,4.505040170589858 50.85893345652808,4.505708064891986 50.85859205342989,4.506315766165072 50.85820844863028,4.506856616306798 50.85778684399775,4.507324689649829 50.85733185775648,4.507714857884673 50.85684847393022,4.508022846246496 50.85634198777566,4.508245280350358 50.85581794780135,4.508379723161668 50.85528209500592,4.508424701696852 50.85474030000001))" +53,"POLYGON((4.457892827922247 50.8605199,4.457858874484171 50.86024758283404,4.457757850216274 50.85998196948838,4.457592242671312 50.85972960041416,4.457366129656659 50.859496690038895,4.457085078825167 50.85928897372083,4.456756010581057 50.85911156649291,4.456387027676617 50.858968837077704,4.455987215695536 50.8588643002789,4.45556641933569 50.85880053040281,4.455135 50.85877909784445,4.454703580664311 50.85880053040281,4.454282784304464 50.8588643002789,4.453882972323384 50.858968837077704,4.453513989418943 50.85911156649291,4.453184921174834 50.85928897372083,4.452903870343341 50.859496690038895,4.452677757328688 50.85972960041416,4.452512149783726 50.85998196948838,4.452411125515829 50.86024758283404,4.452377172077753 50.8605199,4.452411125515829 50.86079221557559,4.452512149783726 50.86105782430586,4.452677757328688 50.86131018619143,4.452903870343341 50.86154308750845,4.453184921174834 50.8617507937854,4.453513989418943 50.86192819097218,4.453882972323384 50.86207091132916,4.454282784304464 50.8621754409393,4.454703580664311 50.8622392062,4.455135 50.862260637168006,4.45556641933569 50.8622392062,4.455987215695536 50.8621754409393,4.456387027676617 50.86207091132916,4.456756010581057 50.86192819097218,4.457085078825167 50.8617507937854,4.457366129656659 50.86154308750845,4.457592242671312 50.86131018619143,4.457757850216274 50.86105782430586,4.457858874484171 50.86079221557559,4.457892827922247 50.8605199))" +54,"POLYGON((4.361865560890918 50.873510700000004,4.361864828473514 50.8734977592311,4.361862634953534 50.87348488440182,4.36185899150865 50.87347214111942,4.361853916705025 50.87345959432089,4.361847436402694 50.87344730794203,4.361839583623793 50.873435344591634,4.361830398384281 50.87342376523245,4.361819927490036 50.87341262887057,4.361808224298333 50.87340199225465,4.361795348445956 50.873391909586836,4.361781365545294 50.87338243224646,4.361766346850007 50.87337360852825,4.361750368891923 50.873365483396235,4.361733513091052 50.87335809825462,4.361715865340694 50.87335149073672,4.361697515569738 50.8733456945133,4.361678557284411 50.87334073912088,4.36165908709179 50.87333664981128,4.361639204207513 50.87333344742291,4.361619009950201 50.87333114827459,4.36159860722516 50.8733297640824,4.3615781 50.87332930189993,4.36155759277484 50.8733297640824,4.361537190049799 50.87333114827459,4.361516995792487 50.87333344742291,4.36149711290821 50.87333664981128,4.361477642715588 50.87334073912088,4.361458684430262 50.8733456945133,4.361440334659306 50.87335149073672,4.361422686908948 50.87335809825462,4.361405831108077 50.873365483396235,4.361389853149992 50.87337360852825,4.361374834454705 50.87338243224646,4.361360851554045 50.873391909586836,4.361347975701667 50.87340199225465,4.361336272509964 50.87341262887057,4.361325801615719 50.87342376523245,4.361316616376207 50.873435344591634,4.361308763597306 50.87344730794203,4.361302283294975 50.87345959432089,4.36129720849135 50.87347214111942,4.361293565046467 50.87348488440182,4.361291371526486 50.8734977592311,4.361290639109082 50.873510700000004,4.361291371526486 50.87352364076531,4.361293565046467 50.873536515583886,4.36129720849135 50.87354925884868,4.361302283294975 50.87356180562307,4.361308763597306 50.87357409197175,4.361316616376207 50.87358605528654,4.361325801615719 50.873597634605396,4.361336272509964 50.87360877092307,4.361347975701667 50.873619407491795,4.361360851554045 50.873629490110396,4.361374834454705 50.87363896740054,4.361389853149992 50.873647791068514,4.361405831108077 50.87365591615131,4.361422686908948 50.873663301245735,4.361440334659306 50.87366990871943,4.361458684430262 50.87367570490253,4.361477642715588 50.87368066025934,4.36149711290821 50.87368474953875,4.361516995792487 50.87368795190298,4.361537190049799 50.8736902510337,4.36155759277484 50.87369163521518,4.3615781 50.87369209739405,4.36159860722516 50.87369163521518,4.361619009950201 50.8736902510337,4.361639204207513 50.87368795190298,4.36165908709179 50.87368474953875,4.361678557284411 50.87368066025934,4.361697515569738 50.87367570490253,4.361715865340694 50.87366990871943,4.361733513091052 50.873663301245735,4.361750368891923 50.87365591615131,4.361766346850007 50.873647791068514,4.361781365545294 50.87363896740054,4.361795348445956 50.873629490110396,4.361808224298333 50.873619407491795,4.361819927490036 50.87360877092307,4.361830398384281 50.873597634605396,4.361839583623793 50.87358605528654,4.361847436402694 50.87357409197175,4.361853916705025 50.87356180562307,4.36185899150865 50.87354925884868,4.361862634953534 50.873536515583886,4.361864828473514 50.87352364076531,4.361865560890918 50.873510700000004))" +55,"POLYGON((4.468486712883687 50.84295,4.468233904476733 50.84194209076052,4.467500225904166 50.841032824019806,4.466357494736507 50.84031121323809,4.464917569462323 50.839847904714276,4.463321399999999 50.83968825841131,4.461725230537676 50.839847904714276,4.460285305263492 50.84031121323809,4.459142574095833 50.841032824019806,4.458408895523266 50.84194209076052,4.458156087116312 50.84295,4.458408895523266 50.84395788746695,4.459142574095833 50.844867097206425,4.460285305263492 50.84558863753074,4.461725230537676 50.846051889053314,4.463321399999999 50.84621151358374,4.464917569462323 50.846051889053314,4.466357494736507 50.84558863753074,4.467500225904166 50.844867097206425,4.468233904476733 50.84395788746695,4.468486712883687 50.84295))" +56,"POLYGON((4.350703039711948 50.83724769999999,4.350190999999999 50.83692433280518,4.349678960288051 50.83724769999999,4.350190999999999 50.83757106495415,4.350703039711948 50.83724769999999))" +57,"POLYGON((4.251197443329146 50.8980536,4.251168359834295 50.89770359294939,4.251081427994596 50.89735741806158,4.250937600253478 50.89701886822845,4.250738452417769 50.896691652878864,4.250486166392832 50.896379357328385,4.250183506277152 50.89608540348584,4.24983378807829 50.89581301234751,4.249440843382017 50.89556516869081,4.249008977372654 50.895344588354824,4.248542921664574 50.89515368846696,4.24804778246164 50.89499456094284,4.247528984612579 50.89486894955031,4.246992212175187 50.894778230789846,4.246443346140617 50.894723398801204,4.2458884 50.8947050544625,4.245333453859382 50.894723398801204,4.244784587824813 50.894778230789846,4.24424781538742 50.89486894955031,4.243729017538359 50.89499456094284,4.243233878335427 50.89515368846696,4.242767822627346 50.895344588354824,4.242335956617983 50.89556516869081,4.241943011921709 50.89581301234751,4.241593293722848 50.89608540348584,4.241290633607166 50.896379357328385,4.24103834758223 50.896691652878864,4.240839199746522 50.89701886822845,4.240695372005403 50.89735741806158,4.240608440165705 50.89770359294939,4.240579356670853 50.8980536,4.240608440165705 50.89840360441986,4.240695372005403 50.8987497715304,4.240839199746522 50.89908830877965,4.24103834758223 50.89941550728872,4.241290633607166 50.89972778247806,4.241593293722848 50.90002171332871,4.241943011921709 50.90029407984926,4.242335956617983 50.90054189833821,4.242767822627346 50.90076245405642,4.243233878335427 50.90095333095238,4.243729017538358 50.90111243811537,4.24424781538742 50.90123803266737,4.244784587824813 50.901328738843965,4.245333453859382 50.90138356305534,4.2458884 50.901401904763304,4.246443346140617 50.90138356305534,4.246992212175187 50.901328738843965,4.247528984612579 50.90123803266737,4.24804778246164 50.90111243811537,4.248542921664574 50.90095333095238,4.249008977372654 50.90076245405642,4.249440843382017 50.90054189833821,4.24983378807829 50.90029407984926,4.250183506277152 50.90002171332871,4.250486166392832 50.89972778247806,4.250738452417769 50.89941550728872,4.250937600253478 50.89908830877965,4.251081427994596 50.8987497715304,4.251168359834295 50.89840360441986,4.251197443329146 50.8980536))" +58,"POLYGON((4.408883273294519 50.861537899999995,4.408852907346454 50.861147747486825,4.408762101942936 50.86076134913804,4.408611731589643 50.860382426320186,4.408403244435276 50.8600146284932,4.408138648325102 50.85966149805547,4.407820491464307 50.85932643621687,4.407451837877381 50.859012670229056,4.407036237899892 50.85872322228893,4.406577693986815 50.85846088041568,4.406080622166698 50.85822817158225,4.405549809512896 50.85802733736087,4.404990368041436 50.85786031231783,4.40440768547951 50.85772870536638,4.403807373378718 50.85763378425762,4.403195213072751 50.85757646335983,4.4025771 50.8575572948438,4.401958986927249 50.85757646335983,4.401346826621283 50.85763378425762,4.40074651452049 50.85772870536638,4.400163831958564 50.85786031231783,4.399604390487105 50.85802733736087,4.399073577833303 50.85822817158225,4.398576506013185 50.85846088041568,4.398117962100108 50.85872322228893,4.39770236212262 50.859012670229056,4.397333708535694 50.85932643621687,4.397015551674897 50.85966149805547,4.396750955564724 50.8600146284932,4.396542468410358 50.860382426320186,4.396392098057064 50.86076134913804,4.396301292653547 50.861147747486825,4.396270926705482 50.861537899999995,4.396301292653547 50.86192804924859,4.396392098057064 50.86231443792905,4.396542468410358 50.86269334504643,4.396750955564724 50.86306112174411,4.397015551674897 50.86341422643572,4.397333708535694 50.86374925890077,4.39770236212262 50.864062993016454,4.398117962100108 50.86435240781065,4.398576506013185 50.864614716537965,4.399073577833303 50.864847393499254,4.399604390487105 50.8650481983471,4.400163831958564 50.865215197644,4.40074651452049 50.86534678346617,4.401346826621283 50.86544168887444,4.401958986927249 50.86549900010392,4.4025771 50.86551816535536,4.403195213072751 50.86549900010392,4.403807373378718 50.86544168887444,4.40440768547951 50.86534678346617,4.404990368041436 50.865215197644,4.405549809512896 50.8650481983471,4.406080622166698 50.864847393499254,4.406577693986815 50.864614716537965,4.407036237899892 50.86435240781065,4.407451837877381 50.864062993016454,4.407820491464307 50.86374925890077,4.408138648325102 50.86341422643572,4.408403244435276 50.86306112174411,4.408611731589643 50.86269334504643,4.408762101942936 50.86231443792905,4.408852907346454 50.86192804924859,4.408883273294519 50.861537899999995))" +59,"POLYGON((4.41444529868252 50.884270900000004,4.4102322 50.88161282728981,4.406019101317479 50.884270900000004,4.4102322 50.88692882106653,4.41444529868252 50.884270900000004))" +60,"POLYGON((4.344552933225263 50.8216813,4.344512964370544 50.82116732640073,4.344393442728308 50.82065829707216,4.344195519357306 50.820159114486216,4.343921100367798 50.81967458643587,4.343572828564664 50.819209379718345,4.343154057995752 50.81876797517113,4.342668821650568 50.81835462449428,4.342121792620369 50.81797330927614,4.341518239093755 50.81762770261781,4.340863973621123 50.81732113372752,4.340165297136631 50.817056555826596,4.33942893827676 50.81683651767787,4.338661988579867 50.816663139011496,4.337871834190789 50.816538090086105,4.337066084728236 50.81646257558298,4.336252499999999 50.81643732298936,4.335438915271762 50.81646257558298,4.334633165809208 50.816538090086105,4.33384301142013 50.816663139011496,4.333076061723237 50.81683651767787,4.332339702863367 50.817056555826596,4.331641026378875 50.81732113372752,4.330986760906242 50.81762770261781,4.330383207379628 50.81797330927614,4.329836178349431 50.81835462449428,4.329350942004245 50.81876797517113,4.328932171435334 50.819209379718345,4.3285838996322 50.81967458643587,4.328309480642692 50.820159114486216,4.32811155727169 50.82065829707216,4.327992035629454 50.82116732640073,4.327952066774734 50.8216813,4.327992035629454 50.82219526794177,4.32811155727169 50.82270428051532,4.328309480642692 50.823203435892566,4.3285838996322 50.82368792732617,4.328932171435334 50.82415308942606,4.329350942004245 50.82459444306939,4.329836178349431 50.8250077385123,4.330383207379628 50.82538899628907,4.330986760906242 50.82573454550602,4.331641026378875 50.826041059162385,4.332339702863367 50.82630558615943,4.333076061723237 50.82652557969051,4.33384301142013 50.826698921740146,4.334633165809208 50.82682394345685,4.335438915271762 50.82689944120494,4.336252499999999 50.82692468814108,4.337066084728236 50.82689944120494,4.337871834190789 50.82682394345685,4.338661988579867 50.826698921740146,4.33942893827676 50.82652557969051,4.340165297136631 50.82630558615943,4.340863973621123 50.826041059162385,4.341518239093755 50.82573454550602,4.342121792620369 50.82538899628907,4.342668821650568 50.8250077385123,4.343154057995752 50.82459444306939,4.343572828564664 50.82415308942606,4.343921100367798 50.82368792732617,4.344195519357306 50.823203435892566,4.344393442728308 50.82270428051532,4.344512964370544 50.82219526794177,4.344552933225263 50.8216813))" +61,"POLYGON((4.444316005057458 50.8962476,4.444282022962561 50.89600261433292,4.44418110920663 50.895765071200735,4.444016330003072 50.895542188398714,4.443792692084607 50.89534073836452,4.443516990576218 50.89516684237013,4.443197602528729 50.895025784492205,4.442844232386343 50.89492185101759,4.442467617122024 50.89485820016887,4.442079199999999 50.894836766112256,4.441690782877976 50.89485820016887,4.441314167613657 50.89492185101759,4.440960797471272 50.895025784492205,4.440641409423782 50.89516684237013,4.440365707915394 50.89534073836452,4.440142069996928 50.895542188398714,4.439977290793371 50.895765071200735,4.439876377037438 50.89600261433292,4.439842394942542 50.8962476,4.439876377037438 50.896492584378294,4.439977290793371 50.89673012379958,4.440142069996928 50.89695300091616,4.440365707915394 50.89715444397615,4.440641409423782 50.89732833254872,4.440960797471272 50.89746938345245,4.441314167613657 50.89757331124161,4.441690782877976 50.89763695837943,4.442079199999999 50.89765839114727,4.442467617122024 50.89763695837943,4.442844232386343 50.89757331124161,4.443197602528729 50.89746938345245,4.443516990576218 50.89732833254872,4.443792692084607 50.89715444397615,4.444016330003072 50.89695300091616,4.44418110920663 50.89673012379958,4.444282022962561 50.896492584378294,4.444316005057458 50.8962476))" +62,"POLYGON((4.387743273048958 50.900545,4.387736278486867 50.90041586875934,4.38771532741247 50.90028733923252,4.387680517509347 50.90016001069097,4.387632011077335 50.9000344768114,4.387570034275813 50.89991132290758,4.387494876069237 50.89979112320096,4.387406886879863 50.8996744381431,4.387306476953909 50.899561811802016,4.387194114448799 50.89945376932502,4.387070323250402 50.899350814489615,4.38693568053043 50.899253427354054,4.386790814055396 50.89916206201842,4.386636399259678 50.899077144506734,4.386473156096337 50.89899907077995,4.386301845680358 50.89892820488909,4.386123266739976 50.898864877277255,4.38593825189265 50.89880938323833,4.385747663763003 50.898761981539565,4.385552390960875 50.898722893214575,4.385353343938212 50.898692300532296,4.385151450744115 50.89867034614681,4.384947652697854 50.89865713243186,4.3847429 50.89865272100333,4.384538147302144 50.89865713243186,4.384334349255884 50.89867034614681,4.384132456061788 50.898692300532296,4.383933409039124 50.898722893214575,4.383738136236996 50.898761981539565,4.383547548107349 50.89880938323833,4.383362533260023 50.898864877277255,4.383183954319642 50.89892820488909,4.383012643903661 50.89899907077995,4.382849400740321 50.899077144506734,4.382694985944604 50.89916206201842,4.38255011946957 50.899253427354054,4.382415476749596 50.899350814489615,4.382291685551199 50.89945376932502,4.38217932304609 50.899561811802016,4.382078913120136 50.8996744381431,4.381990923930762 50.89979112320096,4.381915765724186 50.89991132290758,4.381853788922664 50.9000344768114,4.381805282490653 50.90016001069097,4.38177047258753 50.90028733923252,4.381749521513132 50.90041586875934,4.38174252695104 50.900545,4.381749521513132 50.900674130882535,4.38177047258753 50.90080265934167,4.381805282490653 50.900929986125846,4.381853788922664 50.9010555175911,4.381915765724186 50.901178668468646,4.381990923930762 50.90129886459338,4.382078913120136 50.901415545580484,4.38217932304609 50.901528167437775,4.382291685551199 50.90163620510146,4.382415476749596 50.90173915488371,4.38255011946957 50.90183653682039,4.382694985944604 50.901927896908255,4.382849400740321 50.90201280922105,4.383012643903661 50.90209087789468,4.383183954319642 50.902161738972225,4.383362533260023 50.902225062100264,4.383547548107349 50.90228055206843,4.383738136236996 50.90232795018533,4.383933409039124 50.90236703548403,4.384132456061788 50.902397625752,4.384334349255884 50.90241957838011,4.384538147302144 50.90243279102737,4.3847429 50.90243720209777,4.384947652697854 50.90243279102737,4.385151450744115 50.90241957838011,4.385353343938212 50.902397625752,4.385552390960875 50.90236703548403,4.385747663763003 50.90232795018533,4.38593825189265 50.90228055206843,4.386123266739976 50.902225062100264,4.386301845680358 50.902161738972225,4.386473156096337 50.90209087789468,4.386636399259678 50.90201280922105,4.386790814055396 50.901927896908255,4.38693568053043 50.90183653682039,4.387070323250402 50.90173915488371,4.387194114448799 50.90163620510146,4.387306476953909 50.901528167437775,4.387406886879863 50.901415545580484,4.387494876069237 50.90129886459338,4.387570034275813 50.901178668468646,4.387632011077335 50.9010555175911,4.387680517509347 50.900929986125846,4.38771532741247 50.90080265934167,4.387736278486867 50.900674130882535,4.387743273048958 50.900545))" +63,"POLYGON((4.409843172323312 50.7953754,4.40984017047359 50.79533919458346,4.409831197813316 50.79530338581345,4.409816352648836 50.795268366019705,4.409795797626876 50.79523451888862,4.409769757952559 50.79520221525937,4.409738518922007 50.795171809060854,4.409702422796574 50.795143633433725,4.409661865052966 50.79511799708039,4.409617290050307 50.79509518088246,4.409569186161656 50.79507543482329,4.409518080423282 50.79505897524885,4.40946453276035 50.795045982497214,4.409409129852261 50.795036598922664,4.409352478704869 50.79503092733577,4.409295199999999 50.79502902987701,4.40923792129513 50.79503092733577,4.409181270147738 50.795036598922664,4.409125867239648 50.795045982497214,4.409072319576716 50.79505897524885,4.409021213838344 50.79507543482329,4.408973109949692 50.79509518088246,4.408928534947033 50.79511799708039,4.408887977203425 50.795143633433725,4.408851881077992 50.795171809060854,4.40882064204744 50.79520221525937,4.408794602373123 50.79523451888862,4.408774047351163 50.795268366019705,4.408759202186682 50.79530338581345,4.408750229526409 50.79533919458346,4.408747227676686 50.7953754,4.408750229526409 50.795411605388495,4.408759202186682 50.795447414075596,4.408774047351163 50.79548243373516,4.408794602373123 50.79551628068671,4.40882064204744 50.79554858409889,4.408851881077992 50.79557899005229,4.408887977203425 50.79560716541695,4.408928534947033 50.795632801501974,4.408973109949692 50.79565561743744,4.409021213838344 50.79567536325148,4.409072319576716 50.795691822608866,4.409125867239648 50.795704815180954,4.409181270147738 50.79571419862135,4.40923792129513 50.79571987012531,4.409295199999999 50.795721767556046,4.409352478704869 50.79571987012531,4.409409129852261 50.79571419862135,4.40946453276035 50.795704815180954,4.409518080423282 50.795691822608866,4.409569186161656 50.79567536325148,4.409617290050307 50.79565561743744,4.409661865052966 50.795632801501974,4.409702422796574 50.79560716541695,4.409738518922007 50.79557899005229,4.409769757952559 50.79554858409889,4.409795797626876 50.79551628068671,4.409816352648836 50.79548243373516,4.409831197813316 50.795447414075596,4.40984017047359 50.795411605388495,4.409843172323312 50.7953754))" +64,"POLYGON((4.316121670168441 50.856054500000006,4.31550351334685 50.854092668307025,4.313743151654561 50.852429443068836,4.311108584201506 50.85131807843907,4.3080009 50.85092781279719,4.304893215798493 50.85131807843907,4.302258648345439 50.852429443068836,4.300498286653149 50.854092668307025,4.29988012983156 50.856054500000006,4.300498286653149 50.858016249168344,4.302258648345439 50.859679275174436,4.304893215798493 50.860790440572096,4.3080009 50.861180623689336,4.311108584201506 50.860790440572096,4.313743151654561 50.859679275174436,4.31550351334685 50.858016249168344,4.316121670168441 50.856054500000006))" +65,"POLYGON((4.386861817092718 50.849266,4.386850556790883 50.8490941118129,4.386816852804654 50.8489233971695,4.386760935366435 50.84875502224317,4.386683186449027 50.848590137236876,4.386584137156372 50.84842986852531,4.386464464095575 50.848275310959366,4.386324984754987 50.84812752038584,4.386166651919934 50.84798750643313,4.385990547164229 50.847856225612695,4.385797873461919 50.84773457478301,4.38558994696976 50.84762338502098,4.385368188036528 50.847523415942774,4.385134111500599 50.84743535051274,4.384889316342062 50.847359790376004,4.384635474760071 50.84729725174681,4.38437432075002 50.84724816188051,4.384107638258606 50.84721285615356,4.383837248997659 50.84719157577137,4.383564999999999 50.847184466119764,4.383292751002341 50.84719157577137,4.383022361741394 50.84721285615356,4.382755679249979 50.84724816188051,4.382494525239928 50.84729725174681,4.382240683657938 50.847359790376004,4.3819958884994 50.84743535051274,4.381761811963471 50.847523415942774,4.381540053030239 50.84762338502098,4.38133212653808 50.84773457478301,4.381139452835771 50.847856225612695,4.380963348080065 50.84798750643313,4.380805015245013 50.84812752038584,4.380665535904424 50.848275310959366,4.380545862843627 50.84842986852531,4.380446813550973 50.848590137236876,4.380369064633564 50.84875502224317,4.380313147195345 50.8489233971695,4.380279443209117 50.8490941118129,4.380268182907281 50.849266,4.380279443209117 50.84943788755373,4.380313147195345 50.84960860031427,4.380369064633564 50.84977697215961,4.380446813550973 50.84994185297084,4.380545862843627 50.8501021164877,4.380665535904424 50.85025666800097,4.380805015245013 50.850404451828986,4.380963348080065 50.850544458527324,4.381139452835771 50.85067573178242,4.38133212653808 50.85079737494216,4.381540053030239 50.850908557138844,4.381761811963471 50.851008518962686,4.3819958884994 50.851096577647205,4.382240683657938 50.851172131731275,4.382494525239928 50.85123466516576,4.382755679249979 50.85128375083699,4.383022361741394 50.85131905348297,4.383292751002341 50.8513403319823,4.383564999999999 50.85134744100052,4.383837248997659 50.8513403319823,4.384107638258606 50.85131905348297,4.38437432075002 50.85128375083699,4.384635474760071 50.85123466516576,4.384889316342062 50.851172131731275,4.385134111500599 50.851096577647205,4.385368188036528 50.851008518962686,4.38558994696976 50.850908557138844,4.385797873461919 50.85079737494216,4.385990547164229 50.85067573178242,4.386166651919934 50.850544458527324,4.386324984754987 50.850404451828986,4.386464464095575 50.85025666800097,4.386584137156372 50.8501021164877,4.386683186449027 50.84994185297084,4.386760935366435 50.84977697215961,4.386816852804654 50.84960860031427,4.386850556790883 50.84943788755373,4.386861817092718 50.849266))" +66,"POLYGON((4.411521951144342 50.8846251,4.411519011354 50.88458262112747,4.411510214356547 50.884540465506525,4.41149562710245 50.8844989539682,4.411475360609518 50.884458402442505,4.411449569118002 50.88441911955393,4.411418448916724 50.88438140427256,4.411382236849206 50.88434554363862,4.411341208511149 50.88431181057776,4.411295676152979 50.88428046182382,4.411245986303433 50.8842517359648,4.411192517132271 50.88422585162687,4.411135675572171 50.88420300581036,4.411075894221728 50.88418337239032,4.411013628053115 50.88416710079307,4.410949350949472 50.88415431485886,4.41088355209837 50.88414511189929,4.410816732268795 50.88413956195657,4.4107494 50.88413770727041,4.410682067731204 50.88413956195657,4.41061524790163 50.88414511189929,4.410549449050529 50.88415431485886,4.410485171946886 50.88416710079307,4.410422905778272 50.88418337239032,4.410363124427828 50.88420300581036,4.410306282867729 50.88422585162687,4.410252813696568 50.8842517359648,4.410203123847022 50.88428046182382,4.410157591488852 50.88431181057776,4.410116563150795 50.88434554363862,4.410080351083277 50.88438140427256,4.410049230881998 50.88441911955393,4.410023439390482 50.884458402442505,4.41000317289755 50.8844989539682,4.409988585643452 50.884540465506525,4.409979788646001 50.88458262112747,4.409976848855657 50.8846251,4.409979788646001 50.88466757883379,4.409988585643452 50.884709734339715,4.41000317289755 50.88475124569023,4.410023439390482 50.88479179696104,4.410049230881998 50.884831079535374,4.410080351083277 50.884868794452714,4.410116563150795 50.88490465468389,4.410157591488852 50.88493838731551,4.410203123847022 50.88496973562673,4.410252813696568 50.88499846104305,4.410306282867729 50.885024344951724,4.410363124427828 50.88504719036547,4.410422905778272 50.8850668234215,4.410485171946886 50.885083094704505,4.410549449050529 50.88509588038382,4.41061524790163 50.88510508315558,4.410682067731204 50.885110632983285,4.4107494 50.8851124876307,4.410816732268795 50.885110632983285,4.41088355209837 50.88510508315558,4.410949350949472 50.88509588038382,4.411013628053115 50.885083094704505,4.411075894221728 50.8850668234215,4.411135675572171 50.88504719036547,4.411192517132271 50.885024344951724,4.411245986303433 50.88499846104305,4.411295676152979 50.88496973562673,4.411341208511149 50.88493838731551,4.411382236849206 50.88490465468389,4.411418448916724 50.884868794452714,4.411449569118002 50.884831079535374,4.411475360609518 50.88479179696104,4.41149562710245 50.88475124569023,4.411510214356547 50.884709734339715,4.411519011354 50.88466757883379,4.411521951144342 50.8846251))" +67,"POLYGON((4.356581496282088 50.8775514,4.356549226955523 50.877085047368816,4.35645266456489 50.8766222393489,4.356292544008286 50.87616649834651,4.356070083899832 50.875721293083565,4.355786977295276 50.875290012190646,4.355445378806826 50.87487593840692,4.35504788820524 50.874482223583364,4.354597530634007 50.87411186468015,4.354097733586179 50.87376768094113,4.353552300819074 50.8734522924198,4.352965383405393 50.87316810002069,4.352341448141043 50.87291726720853,4.351685243550129 50.87270170352512,4.351001763745815 50.87252305003974,4.350296210422107 50.87238266684444,4.349573953265824 50.872281622689876,4.348840489090037 50.87222068684074,4.348101399999999 50.87220032321349,4.347362310909962 50.87222068684074,4.346628846734174 50.872281622689876,4.345906589577892 50.87238266684444,4.345201036254184 50.87252305003974,4.344517556449869 50.87270170352512,4.343861351858955 50.87291726720853,4.343237416594605 50.87316810002069,4.342650499180924 50.8734522924198,4.34210506641382 50.87376768094113,4.341605269365992 50.87411186468015,4.341154911794759 50.874482223583364,4.340757421193173 50.87487593840692,4.340415822704722 50.875290012190646,4.340132716100166 50.875721293083565,4.339910255991713 50.87616649834651,4.339750135435109 50.8766222393489,4.339653573044475 50.877085047368816,4.33962130371791 50.8775514,4.339653573044475 50.878017747964215,4.339750135435109 50.87848054212501,4.339910255991713 50.878936260497206,4.340132716100166 50.87938143504653,4.340415822704722 50.879812678075595,4.340757421193173 50.88022670799572,4.341154911794759 50.88062037428869,4.341605269365992 50.88099068146894,4.34210506641382 50.88133481186416,4.342650499180924 50.88165014704168,4.343237416594605 50.881934287717804,4.343861351858955 50.88218507199938,4.344517556449869 50.88240059181919,4.345201036254184 50.88257920744071,4.345906589577892 50.8827195599224,4.346628846734174 50.882820581446786,4.347362310909962 50.882881503436785,4.348101399999999 50.88290186239706,4.348840489090037 50.882881503436785,4.349573953265824 50.882820581446786,4.350296210422107 50.8827195599224,4.351001763745815 50.88257920744071,4.351685243550129 50.88240059181919,4.352341448141043 50.88218507199938,4.352965383405393 50.881934287717804,4.353552300819074 50.88165014704168,4.354097733586179 50.88133481186416,4.354597530634007 50.88099068146894,4.35504788820524 50.88062037428869,4.355445378806826 50.88022670799572,4.355786977295276 50.879812678075595,4.356070083899832 50.87938143504653,4.356292544008286 50.878936260497206,4.35645266456489 50.87848054212501,4.356549226955523 50.878017747964215,4.356581496282088 50.8775514))" +68,"POLYGON((4.497506176063291 50.839488,4.497479547032153 50.83910284635907,4.497399862601747 50.83872062082713,4.497267729218703 50.83834423247877,4.497084152497848 50.83797654603208,4.496850529568878 50.837620360041186,4.496568638443344 50.83727838559022,4.496240624482925 50.83695322565148,4.495868984071919 50.83664735526482,4.495456545618255 50.836363102689816,4.495006448027605 50.8361026316739,4.494522116814408 50.83586792497258,4.494007238031645 50.83566076924674,4.493465730217744 50.835482741452985,4.492901714574142 50.835335196830535,4.492319483600446 50.835219258576764,4.49172346842593 50.83513580929002,4.491118205085952 50.83508548424528,4.490508299999999 50.835068666554044,4.489898394914047 50.83508548424528,4.48929313157407 50.83513580929002,4.488697116399552 50.835219258576764,4.488114885425858 50.835335196830535,4.487550869782255 50.835482741452985,4.487009361968354 50.83566076924674,4.486494483185592 50.83586792497258,4.486010151972393 50.8361026316739,4.485560054381743 50.836363102689816,4.48514761592808 50.83664735526482,4.484775975517074 50.83695322565148,4.484447961556654 50.83727838559022,4.484166070431122 50.837620360041186,4.48393244750215 50.83797654603208,4.483748870781296 50.83834423247877,4.483616737398251 50.83872062082713,4.483537052967846 50.83910284635907,4.483510423936708 50.839488,4.483537052967846 50.83987315046197,4.483616737398251 50.84025536655359,4.483748870781296 50.84063173948714,4.48393244750215 50.84099940501286,4.484166070431122 50.84135556521232,4.484447961556654 50.84169750978505,4.484775975517074 50.84202263666659,4.48514761592808 50.8423284718215,4.485560054381743 50.842612688060726,4.486010151972393 50.842873122740855,4.486494483185592 50.843107794210425,4.487009361968354 50.84331491687906,4.487550869782255 50.843492914794595,4.488114885425858 50.84364043362561,4.488697116399552 50.843756350958415,4.48929313157407 50.843839784830344,4.489898394914047 50.84389010043476,4.490508299999999 50.84390691494703,4.491118205085952 50.84389010043476,4.49172346842593 50.843839784830344,4.492319483600446 50.843756350958415,4.492901714574142 50.84364043362561,4.493465730217744 50.843492914794595,4.494007238031645 50.84331491687906,4.494522116814408 50.843107794210425,4.495006448027605 50.842873122740855,4.495456545618255 50.842612688060726,4.495868984071919 50.8423284718215,4.496240624482925 50.84202263666659,4.496568638443344 50.84169750978505,4.496850529568878 50.84135556521232,4.497084152497848 50.84099940501286,4.497267729218703 50.84063173948714,4.497399862601747 50.84025536655359,4.497479547032153 50.83987315046197,4.497506176063291 50.839488))" +69,"POLYGON((4.329358180395102 50.86193109999999,4.3225759 50.85764998713042,4.315793619604897 50.86193109999999,4.3225759 50.86621181982402,4.329358180395102 50.86193109999999))" +70,"POLYGON((4.233737896516615 50.829637600000005,4.23372457663468 50.82942346888366,4.233684699110379 50.82921065698366,4.233618509801907 50.82900047638312,4.233526416788363 50.82879422295951,4.2334089878538 50.82859316839417,4.233266946986647 50.82839855233039,4.233101169916083 50.82821157472877,4.232912678712877 50.828033388466906,4.232702635487974 50.82786509222912,4.232472335227704 50.82770772373003,4.232223197809752 50.827562253313936,4.231956759249148 50.82742957796953,4.231674662228217 50.827310515796775,4.231378645968901 50.82720580096029,4.231070535509873 50.827116079160405,4.230752230454569 50.82704190364968,4.230425693259504 50.82698373181988,4.230092937135071 50.82694192238003,4.229756013633428 50.826916733143456,4.229417 50.826908319437145,4.229077986366573 50.826916733143456,4.22874106286493 50.82694192238003,4.228408306740495 50.82698373181988,4.22808176954543 50.82704190364968,4.227763464490127 50.827116079160405,4.2274553540311 50.82720580096029,4.227159337771782 50.827310515796775,4.226877240750852 50.82742957796953,4.226610802190248 50.827562253313936,4.226361664772296 50.82770772373003,4.226131364512026 50.82786509222912,4.225921321287123 50.828033388466906,4.225732830083916 50.82821157472877,4.225567053013354 50.82839855233039,4.2254250121462 50.82859316839417,4.225307583211637 50.82879422295951,4.225215490198092 50.82900047638312,4.225149300889622 50.82921065698366,4.22510942336532 50.82942346888366,4.225096103483385 50.829637600000005,4.22510942336532 50.82985173013407,4.225149300889622 50.83006453911147,4.225215490198092 50.830274714921046,4.225307583211637 50.83048096180328,4.2254250121462 50.83068200823791,4.225567053013354 50.830876614781864,4.225732830083916 50.83106358170894,4.225921321287123 50.831241756404374,4.226131364512026 50.83141004046867,4.226361664772296 50.83156739648694,4.226610802190248 50.83171285442222,4.226877240750852 50.83184551759314,4.227159337771782 50.83196456819948,4.2274553540311 50.8320692723614,4.227763464490127 50.83215898464147,4.22808176954543 50.83223315202148,4.228408306740495 50.83229131730991,4.22874106286493 50.83233312195878,4.229077986366573 50.83235830827277,4.229417 50.832366720996816,4.229756013633428 50.83235830827277,4.230092937135071 50.83233312195878,4.230425693259504 50.83229131730991,4.230752230454569 50.83223315202148,4.231070535509873 50.83215898464147,4.231378645968901 50.8320692723614,4.231674662228217 50.83196456819948,4.231956759249148 50.83184551759314,4.232223197809752 50.83171285442222,4.232472335227704 50.83156739648694,4.232702635487974 50.83141004046867,4.232912678712877 50.831241756404374,4.233101169916083 50.83106358170894,4.233266946986647 50.830876614781864,4.2334089878538 50.83068200823791,4.233526416788363 50.83048096180328,4.233618509801907 50.830274714921046,4.233684699110379 50.83006453911147,4.23372457663468 50.82985173013407,4.233737896516615 50.829637600000005))" +71,"POLYGON((4.411800416009766 50.8582277,4.41178766552374 50.858043355586624,4.41174951110456 50.85786041342512,4.411686243130394 50.857680265840415,4.411598343108725 50.85750428390465,4.411486480011798 50.85733380700123,4.411351505185324 50.857170132629655,4.411194445869231 50.85701450652871,4.411016497379751 50.85686811319327,4.410819014012335 50.856732066857,4.410603498734656 50.856607403009484,4.410371591748105 50.85649507051276,4.410125058004883 50.856395924376905,4.409865773775634 50.85631071925016,4.409595712369903 50.85624010367299,4.409316929118057 50.8561846151399,4.409031545728976 50.85614467600674,4.408741734142568 50.85612059027468,4.408449699999999 50.856112541275316,4.408157665857432 50.85612059027468,4.407867854271025 50.85614467600674,4.407582470881942 50.8561846151399,4.407303687630096 50.85624010367299,4.407033626224366 50.85631071925016,4.406774341995117 50.856395924376905,4.406527808251894 50.85649507051276,4.406295901265343 50.856607403009484,4.406080385987664 50.856732066857,4.405882902620249 50.85686811319327,4.405704954130768 50.85701450652871,4.405547894814675 50.857170132629655,4.4054129199882 50.85733380700123,4.405301056891274 50.85750428390465,4.405213156869607 50.857680265840415,4.40514988889544 50.85786041342512,4.40511173447626 50.858043355586624,4.405098983990234 50.8582277,4.40511173447626 50.85841204368464,4.40514988889544 50.85859498368208,4.405213156869607 50.858775127733146,4.405301056891274 50.85895110487306,4.4054129199882 50.85912157586414,4.405547894814675 50.85928524338653,4.405704954130768 50.859440861909555,4.405882902620249 50.85958724716859,4.406080385987664 50.85972328517538,4.406295901265343 50.859847940693385,4.406527808251894 50.85996026511371,4.406774341995117 50.86005940367165,4.407033626224366 50.86014460194921,4.407303687630096 50.86021521161403,4.407582470881942 50.860270695351275,4.407867854271025 50.86031063095079,4.408157665857432 50.86033471451879,4.408449699999999 50.86034276278942,4.408741734142568 50.86033471451879,4.409031545728976 50.86031063095079,4.409316929118057 50.860270695351275,4.409595712369903 50.86021521161403,4.409865773775634 50.86014460194921,4.410125058004883 50.86005940367165,4.410371591748105 50.85996026511371,4.410603498734656 50.859847940693385,4.410819014012335 50.85972328517538,4.411016497379751 50.85958724716859,4.411194445869231 50.859440861909555,4.411351505185324 50.85928524338653,4.411486480011798 50.85912157586414,4.411598343108725 50.85895110487306,4.411686243130394 50.858775127733146,4.41174951110456 50.85859498368208,4.41178766552374 50.85841204368464,4.411800416009766 50.8582277))" +72,"POLYGON((4.384291255598933 50.876395,4.384282846431207 50.87627346909993,4.384257682926867 50.876152862810066,4.384215956595379 50.87603409902783,4.38415798499932 50.87591808163478,4.384084209337541 50.875805693617124,4.383995191087371 50.87569779034479,4.383891607731449 50.87559519306076,4.383774247601659 50.87549868262985,4.383644003879449 50.87540899359469,4.38350186779819 50.87532680858426,4.383348921099286 50.875252753117366,4.383186327799467 50.87518739084082,4.383015325331919 50.87513121923853,4.382837215128676 50.87508466584424,4.38265335271593 50.875048084986666,4.382465137397661 50.875021755091986,4.38227400160609 50.87500587656407,4.3820814 50.87500057025883,4.381888798393909 50.87500587656407,4.381697662602337 50.875021755091986,4.381509447284069 50.875048084986666,4.381325584871323 50.87508466584424,4.38114747466808 50.87513121923853,4.380976472200533 50.87518739084082,4.380813878900712 50.875252753117366,4.380660932201808 50.87532680858426,4.38051879612055 50.87540899359469,4.380388552398341 50.87549868262985,4.380271192268549 50.87559519306076,4.380167608912628 50.87569779034479,4.38007859066246 50.875805693617124,4.380004815000679 50.87591808163478,4.379946843404619 50.87603409902783,4.379905117073132 50.876152862810066,4.379879953568793 50.87627346909993,4.379871544401065 50.876395,4.379879953568793 50.87651653058313,4.379905117073132 50.87663713593184,4.379946843404619 50.87675589817728,4.380004815000679 50.87687191348457,4.38007859066246 50.87698429893093,4.380167608912628 50.877092199224506,4.380271192268549 50.877194793212844,4.380388552398341 50.8772913001313,4.38051879612055 50.8773809855439,4.380660932201808 50.877463166931776,4.380813878900712 50.877537218886204,4.380976472200533 50.877602577867066,4.38114747466808 50.8776587464906,4.381325584871323 50.877705297313575,4.381509447284069 50.87774187608541,4.381697662602337 50.8777682044433,4.381888798393909 50.87778408203004,4.3820814 50.87778938801835,4.38227400160609 50.87778408203004,4.382465137397661 50.8777682044433,4.38265335271593 50.87774187608541,4.382837215128676 50.877705297313575,4.383015325331919 50.8776587464906,4.383186327799467 50.877602577867066,4.383348921099286 50.877537218886204,4.38350186779819 50.877463166931776,4.383644003879449 50.8773809855439,4.383774247601659 50.8772913001313,4.383891607731449 50.877194793212844,4.383995191087371 50.877092199224506,4.384084209337541 50.87698429893093,4.38415798499932 50.87687191348457,4.384215956595379 50.87675589817728,4.384257682926867 50.87663713593184,4.384282846431207 50.87651653058313,4.384291255598933 50.876395))" +73,"POLYGON((4.454580583275621 50.8962575,4.4544992449186 50.895933589170916,4.454263191812644 50.895641383057665,4.453895530480441 50.89540948566833,4.453432250174834 50.89526059777065,4.4529187 50.89520929438722,4.452405149825165 50.89526059777065,4.451941869519557 50.89540948566833,4.451574208187354 50.895641383057665,4.451338155081398 50.895933589170916,4.451256816724379 50.8962575,4.451338155081398 50.89658140857615,4.451574208187354 50.896873608791125,4.451941869519557 50.897105498889815,4.452405149825165 50.89725438088924,4.4529187 50.897305682019734,4.453432250174834 50.89725438088924,4.453895530480441 50.897105498889815,4.454263191812644 50.896873608791125,4.4544992449186 50.89658140857615,4.454580583275621 50.8962575))" +74,"POLYGON((4.470251064753676 50.765198,4.470089848169093 50.76416267511384,4.469612393878273 50.76316711557646,4.468837050181855 50.76224958389501,4.467793613103276 50.76144534585372,4.466522181344296 50.76078531442362,4.46507161531439 50.76029486079662,4.463497659452596 50.759992838386985,4.4618608 50.75989085745924,4.460223940547405 50.759992838386985,4.458649984685612 50.76029486079662,4.457199418655705 50.76078531442362,4.455927986896725 50.76144534585372,4.454884549818146 50.76224958389501,4.454109206121728 50.76316711557646,4.453631751830908 50.76416267511384,4.453470535246324 50.765198,4.453631751830908 50.76623330197664,4.454109206121728 50.76722879627323,4.454884549818146 50.76814623031495,4.455927986896725 50.76895035318232,4.457199418655705 50.76961026943851,4.458649984685612 50.770100625425776,4.460223940547405 50.770402582594635,4.4618608 50.770504540612855,4.463497659452596 50.770402582594635,4.46507161531439 50.770100625425776,4.466522181344296 50.76961026943851,4.467793613103276 50.76895035318232,4.468837050181855 50.76814623031495,4.469612393878273 50.76722879627323,4.470089848169093 50.76623330197664,4.470251064753676 50.765198))" +75,"POLYGON((4.339717581958141 50.87307870000001,4.339570283894556 50.87225372953237,4.339135775843774 50.87147011300666,4.338435845853806 50.87076714725349,4.337505591337004 50.87018008628365,4.336391659139245 50.86973837263885,4.335149906472301 50.86946416005834,4.3338426 50.86937120173198,4.332535293527697 50.86946416005834,4.331293540860752 50.86973837263885,4.330179608662994 50.87018008628365,4.329249354146192 50.87076714725349,4.328549424156226 50.87147011300666,4.328114916105442 50.87225372953237,4.327967618041858 50.87307870000001,4.328114916105442 50.87390365586569,4.328549424156226 50.874687231477616,4.329249354146192 50.87539013810867,4.330179608662994 50.8759771334579,4.331293540860752 50.87641878798058,4.332535293527697 50.8766929596473,4.3338426 50.87678590337172,4.335149906472301 50.8766929596473,4.336391659139245 50.87641878798058,4.337505591337004 50.8759771334579,4.338435845853806 50.87539013810867,4.339135775843774 50.874687231477616,4.339570283894556 50.87390365586569,4.339717581958141 50.87307870000001))" +76,"POLYGON((4.320100821904616 50.878155899999996,4.320024910714041 50.87779207861004,4.319802350364505 50.87745304848983,4.31944830797603 50.87716191475705,4.318986910952308 50.87693851875351,4.318449602738012 50.876798085606694,4.317873 50.87675018637876,4.317296397261988 50.876798085606694,4.316759089047691 50.87693851875351,4.316297692023969 50.87716191475705,4.315943649635496 50.87745304848983,4.315721089285959 50.87779207861004,4.315645178095384 50.878155899999996,4.315721089285959 50.87851971854945,4.315943649635496 50.878858740909294,4.316297692023969 50.87914986404121,4.316759089047691 50.879373249443894,4.317296397261988 50.87951367483035,4.317873 50.87956157121779,4.318449602738012 50.87951367483035,4.318986910952308 50.879373249443894,4.31944830797603 50.87914986404121,4.319802350364505 50.878858740909294,4.320024910714041 50.87851971854945,4.320100821904616 50.878155899999996))" +77,"POLYGON((4.271400952472855 50.752368000000004,4.271323623747058 50.75187126546457,4.271094609269235 50.751393615187425,4.270722709937335 50.750953405855064,4.270222217634119 50.750567555743686,4.26961236599812 50.75025089436475,4.268916591285703 50.75001559234551,4.268161631728868 50.749870693489086,4.2673765 50.74982176703151,4.266591368271132 50.749870693489086,4.265836408714296 50.75001559234551,4.265140634001879 50.75025089436475,4.264530782365881 50.750567555743686,4.264030290062664 50.750953405855064,4.263658390730764 50.751393615187425,4.26342937625294 50.75187126546457,4.263352047527144 50.752368000000004,4.26342937625294 50.75286472926412,4.263658390730764 50.753342364529885,4.264030290062664 50.75378255139611,4.264530782365881 50.75416837500686,4.265140634001879 50.75448500988518,4.265836408714296 50.75472028943828,4.266591368271132 50.75486517328331,4.2673765 50.75491409446959,4.268161631728868 50.75486517328331,4.268916591285703 50.75472028943828,4.26961236599812 50.75448500988518,4.270222217634119 50.75416837500686,4.270722709937335 50.75378255139611,4.271094609269235 50.753342364529885,4.271323623747058 50.75286472926412,4.271400952472855 50.752368000000004))" +78,"POLYGON((4.433299239354641 50.88149869999999,4.433268517012096 50.881227681966294,4.433176975402762 50.88096217954961,4.433026478049819 50.88070759775307,4.432820088645374 50.88046911934787,4.432562008682527 50.880251599349265,4.432257491925076 50.88005946615946,4.43191273745605 50.87989663139211,4.431534763482253 50.87976641021581,4.431131264463798 50.87967145384081,4.430710454477109 50.87961369552509,4.4302809 50.87959431120092,4.42985134552289 50.87961369552509,4.429430535536201 50.87967145384081,4.429027036517746 50.87976641021581,4.428649062543948 50.87989663139211,4.428304308074923 50.88005946615946,4.427999791317472 50.880251599349265,4.427741711354624 50.88046911934787,4.427535321950179 50.88070759775307,4.427384824597237 50.88096217954961,4.427293282987902 50.881227681966294,4.427262560645358 50.88149869999999,4.427293282987902 50.8817697164573,4.427384824597237 50.8820352142725,4.427535321950179 50.88228978881524,4.427741711354624 50.88252825790201,4.427999791317472 50.88274576727247,4.428304308074923 50.88293788938542,4.428649062543948 50.88310071352463,4.429027036517746 50.883230925382485,4.429430535536201 50.8833258745037,4.42985134552289 50.883383628217935,4.4302809 50.883403010965694,4.430710454477109 50.883383628217935,4.431131264463798 50.8833258745037,4.431534763482253 50.883230925382485,4.43191273745605 50.88310071352463,4.432257491925076 50.88293788938542,4.432562008682527 50.88274576727247,4.432820088645374 50.88252825790201,4.433026478049819 50.88228978881524,4.433176975402762 50.8820352142725,4.433268517012096 50.8817697164573,4.433299239354641 50.88149869999999))" +79,"POLYGON((4.454251956090054 50.83574200000001,4.453070105072356 50.8329563402849,4.449841228045027 50.83091699043276,4.4454305 50.830170514304015,4.441019771954973 50.83091699043276,4.437790894927644 50.8329563402849,4.436609043909946 50.83574200000001,4.437790894927644 50.838527493452666,4.441019771954973 50.84056651077993,4.4454305 50.841312820646216,4.449841228045027 50.84056651077993,4.453070105072356 50.838527493452666,4.454251956090054 50.83574200000001))" +80,"POLYGON((4.312131514569506 50.88463599999999,4.312113293192556 50.88434341720946,4.312058741402555 50.88405263646863,4.311968195529428 50.883765450587916,4.311842213818592 50.88348363024646,4.31168157298919 50.88320891307334,4.31148726344535 50.88294299293164,4.311260483170026 50.8826875094718,4.311002630339028 50.882444038018605,4.310715294700804 50.8822140798542,4.310400247775111 50.881999052957305,4.310059431931012 50.88180028325573,4.309694948411515 50.881618996446235,4.309309044378724 50.88145631043246,4.308904099059327 50.88131322842748,4.308482609075875 50.881190632763705,4.308047173054275 50.88108927944853,4.307600475602398 50.88100979349921,4.307145270758578 50.88095266508602,4.306684365012047 50.88091824650729,4.306220599999999 50.88090675001551,4.305756834987951 50.88091824650729,4.30529592924142 50.88095266508602,4.3048407243976 50.88100979349921,4.304394026945723 50.88108927944853,4.303958590924124 50.881190632763705,4.303537100940671 50.88131322842748,4.303132155621274 50.88145631043246,4.302746251588482 50.881618996446235,4.302381768068987 50.88180028325573,4.302040952224886 50.881999052957305,4.301725905299195 50.8822140798542,4.301438569660971 50.882444038018605,4.301180716829973 50.8826875094718,4.300953936554649 50.88294299293164,4.30075962701081 50.88320891307334,4.300598986181406 50.88348363024646,4.300473004470571 50.883765450587916,4.300382458597444 50.88405263646863,4.300327906807443 50.88434341720946,4.300309685430493 50.88463599999999,4.300327906807443 50.88492858095308,4.300382458597444 50.88521935622681,4.300473004470571 50.885506533145374,4.300598986181406 50.88578834125032,4.30075962701081 50.886063043213866,4.300953936554649 50.886328945547454,4.301180716829973 50.88658440903912,4.301438569660971 50.88682785885578,4.301725905299195 50.88705779424804,4.302040952224886 50.8872727977979,4.302381768068987 50.88747154415245,4.302746251588482 50.88765280818979,4.303132155621274 50.88781547256701,4.303537100940671 50.88795853460385,4.303958590924124 50.8880811124595,4.304394026945723 50.888182450565104,4.3048407243976 50.8882619242779,4.30529592924142 50.88831904372896,4.305756834987951 50.88835345684057,4.306220599999999 50.88836495149491,4.306684365012047 50.88835345684057,4.307145270758578 50.88831904372896,4.307600475602398 50.8882619242779,4.308047173054275 50.888182450565104,4.308482609075875 50.8880811124595,4.308904099059327 50.88795853460385,4.309309044378724 50.88781547256701,4.309694948411515 50.88765280818979,4.310059431931012 50.88747154415245,4.310400247775111 50.8872727977979,4.310715294700804 50.88705779424804,4.311002630339028 50.88682785885578,4.311260483170026 50.88658440903912,4.31148726344535 50.886328945547454,4.31168157298919 50.886063043213866,4.311842213818592 50.88578834125032,4.311968195529428 50.885506533145374,4.312058741402555 50.88521935622681,4.312113293192556 50.88492858095308,4.312131514569506 50.88463599999999))" +81,"POLYGON((4.48949776390525 50.8443733,4.489486846308321 50.84418028072133,4.489454149151102 50.843988244232214,4.489399839050815 50.84379816912475,4.48932419275928 50.84361102400795,4.489227595752658 50.843427762571345,4.489110540267156 50.84324931872442,4.488973622790692 50.84307660183652,4.488817541023346 50.84291049210167,4.488643090322025 50.84275183605198,4.488451159647517 50.84260144224236,4.488242727034542 50.84246007712862,4.488018854607922 50.842328461160186,4.487780683170224 50.84220726510707,4.487529426388502 50.84209710664004,4.487266364609724 50.84199854718141,4.486992838336412 50.84191208904258,4.486710241395761 50.84183817286277,4.486420013837 50.84177717536229,4.486123634593244 50.8417294074216,4.485822613945183 50.84169511249613,4.485518485825039 50.8416744653748,4.4852128 50.841667571288774,4.484907114174962 50.8416744653748,4.484602986054817 50.84169511249613,4.484301965406757 50.8417294074216,4.484005586163001 50.84177717536229,4.48371535860424 50.84183817286277,4.483432761663589 50.84191208904258,4.483159235390277 50.84199854718141,4.482896173611499 50.84209710664004,4.482644916829776 50.84220726510707,4.482406745392079 50.842328461160186,4.482182872965458 50.84246007712862,4.481974440352484 50.84260144224236,4.481782509677975 50.84275183605198,4.481608058976654 50.84291049210167,4.481451977209308 50.84307660183652,4.481315059732846 50.84324931872442,4.481198004247342 50.843427762571345,4.481101407240721 50.84361102400795,4.481025760949185 50.84379816912475,4.480971450848898 50.843988244232214,4.48093875369168 50.84418028072133,4.48092783609475 50.8443733,4.48093875369168 50.84456631848012,4.480971450848898 50.84475835258986,4.481025760949185 50.844948423785574,4.481101407240721 50.84513556353788,4.481198004247342 50.845318818266406,4.481315059732846 50.84549725419827,4.481451977209308 50.84566996212525,4.481608058976654 50.84583606203573,4.481782509677975 50.8459947075976,4.481974440352484 50.84614509046946,4.482182872965458 50.84628644441813,4.482406745392079 50.846418049221505,4.482644916829776 50.846539234336845,4.482896173611499 50.84664938231605,4.483159235390277 50.84674793195031,4.483432761663589 50.846834381128225,4.48371535860424 50.84690828939298,4.484005586163001 50.8469692801854,4.484301965406757 50.84701704276157,4.484602986054817 50.84705133377528,4.484907114174962 50.84707197851725,4.4852128 50.847078871804726,4.485518485825039 50.84707197851725,4.485822613945183 50.84705133377528,4.486123634593244 50.84701704276157,4.486420013837 50.8469692801854,4.486710241395761 50.84690828939298,4.486992838336412 50.846834381128225,4.487266364609724 50.84674793195031,4.487529426388502 50.84664938231605,4.487780683170224 50.846539234336845,4.488018854607922 50.846418049221505,4.488242727034542 50.84628644441813,4.488451159647517 50.84614509046946,4.488643090322025 50.8459947075976,4.488817541023346 50.84583606203573,4.488973622790692 50.84566996212525,4.489110540267156 50.84549725419827,4.489227595752658 50.845318818266406,4.48932419275928 50.84513556353788,4.489399839050815 50.844948423785574,4.489454149151102 50.84475835258986,4.489486846308321 50.84456631848012,4.48949776390525 50.8443733))" +82,"POLYGON((4.269220589170471 50.8774466,4.269218289937691 50.87741522025371,4.269211411855594 50.877384108207494,4.269200013605552 50.877353529299164,4.269184192433414 50.877323744418455,4.269164083319843 50.87729500768128,4.269139857828708 50.877267564261466,4.269111722643354 50.877241648299105,4.269079917803263 50.87721748090274,4.269044714656119 50.877195268262994,4.269006413542759 50.87717519989318,4.268965341234778 50.87715744701241,4.268921848146626 50.877142161084755,4.268876305345998 50.877129472526825,4.268829101388007 50.8771194895951,4.268780639000182 50.877112297462176,4.268731331646528 50.877107957490104,4.2686816 50.8771065067068,4.268631868353471 50.877107957490104,4.268582560999817 50.877112297462176,4.268534098611992 50.8771194895951,4.268486894654001 50.877129472526825,4.268441351853372 50.877142161084755,4.26839785876522 50.87715744701241,4.26835678645724 50.87717519989318,4.26831848534388 50.877195268262994,4.268283282196736 50.87721748090274,4.268251477356645 50.877241648299105,4.268223342171291 50.877267564261466,4.268199116680155 50.87729500768128,4.268179007566585 50.877323744418455,4.268163186394447 50.877353529299164,4.268151788144404 50.877384108207494,4.268144910062308 50.87741522025371,4.268142610829528 50.8774466,4.268144910062308 50.87747797972515,4.268151788144404 50.8775090917087,4.268163186394447 50.87753967051496,4.268179007566585 50.87756945525765,4.268199116680155 50.877598191825584,4.268223342171291 50.8776256350507,4.268251477356645 50.87765155079952,4.268283282196736 50.87767571797076,4.26831848534388 50.877697930381494,4.26835678645724 50.87771799852621,4.26839785876522 50.87773575119342,4.268441351853372 50.87775103692637,4.268486894654001 50.877763725315056,4.268534098611992 50.87777370810878,4.268582560999817 50.877780900139626,4.268631868353471 50.877785240049015,4.2686816 50.8777866908112,4.268731331646528 50.877785240049015,4.268780639000182 50.877780900139626,4.268829101388007 50.87777370810878,4.268876305345998 50.877763725315056,4.268921848146626 50.87775103692637,4.268965341234778 50.87773575119342,4.269006413542759 50.87771799852621,4.269044714656119 50.877697930381494,4.269079917803263 50.87767571797076,4.269111722643354 50.87765155079952,4.269139857828708 50.8776256350507,4.269164083319843 50.877598191825584,4.269184192433414 50.87756945525765,4.269200013605552 50.87753967051496,4.269211411855594 50.8775090917087,4.269218289937691 50.87747797972515,4.269220589170471 50.8774466))" +83,"POLYGON((4.4713770698001 50.84870159999999,4.471338139473707 50.8483892873728,4.471222307088366 50.84808466290464,4.471032424821828 50.84779522768321,4.470773168205681 50.84752810891045,4.470450920998236 50.847289884373325,4.470073617995218 50.84708642043416,4.469650549648758 50.84692272753402,4.46919213330563 50.846802836771616,4.468709656697598 50.84672970060164,4.468215 50.84670512010163,4.467720343302401 50.84672970060164,4.467237866694369 50.846802836771616,4.466779450351241 50.84692272753402,4.466356382004781 50.84708642043416,4.465979079001763 50.847289884373325,4.465656831794319 50.84752810891045,4.465397575178171 50.84779522768321,4.465207692911634 50.84808466290464,4.465091860526292 50.8483892873728,4.465052930199898 50.84870159999999,4.465091860526292 50.84901391053625,4.465207692911634 50.84931852893627,4.465397575178171 50.849607954706364,4.465656831794319 50.84987506156975,4.465979079001763 50.85011327290522,4.466356382004781 50.85031672364272,4.466779450351241 50.85048040463349,4.467237866694369 50.85060028594456,4.467720343302401 50.8506734160464,4.468215 50.85069799445548,4.468709656697598 50.8506734160464,4.46919213330563 50.85060028594456,4.469650549648758 50.85048040463349,4.470073617995218 50.85031672364272,4.470450920998236 50.85011327290522,4.470773168205681 50.84987506156975,4.471032424821828 50.849607954706364,4.471222307088366 50.84931852893627,4.471338139473707 50.84901391053625,4.4713770698001 50.84870159999999))" +84,"POLYGON((4.350608466908548 50.838168800000005,4.350605356200161 50.8381238066182,4.350596047749369 50.83807915562033,4.350580612399103 50.8380351868289,4.3505591676217 50.837992234875344,4.350531876624862 50.83795062665323,4.350498947109555 50.83791067883026,4.350460629689276 50.83787269543812,4.350417215982727 50.837836965558495,4.350369036394429 50.83780376112284,4.350316457600143 50.83777333484258,4.35025987975624 50.83774591828575,4.350199733454273 50.837721720114345,4.35013647644392 50.837700924496225,4.350070590149224 50.83768368970323,4.350002576004673 50.837670146906554,4.349932951638972 50.83766039917832,4.349862246935586 50.83765452070699,4.349791 50.837652556232776,4.349719753064413 50.83765452070699,4.349649048361027 50.83766039917832,4.349579423995326 50.837670146906554,4.349511409850773 50.83768368970323,4.349445523556078 50.837700924496225,4.349382266545724 50.837721720114345,4.349322120243759 50.83774591828575,4.349265542399856 50.83777333484258,4.349212963605569 50.83780376112284,4.349164784017272 50.837836965558495,4.349121370310723 50.83787269543812,4.349083052890443 50.83791067883026,4.349050123375137 50.83795062665323,4.349022832378299 50.837992234875344,4.349001387600896 50.8380351868289,4.348985952250629 50.83807915562033,4.348976643799838 50.8381238066182,4.348973533091451 50.838168800000005,4.348976643799838 50.838213793338404,4.348985952250629 50.838258444207455,4.349001387600896 50.83830241278854,4.349022832378299 50.8383453644566,4.349050123375137 50.83838697232676,4.349083052890443 50.838426919742005,4.349121370310723 50.838464902683036,4.349164784017272 50.83850063208188,4.349212963605569 50.83853383602169,4.349265542399856 50.838564261806106,4.349322120243759 50.83859167788216,4.349382266545724 50.83861587560246,4.349445523556078 50.83863667081285,4.349511409850773 50.83865390525388,4.349579423995326 50.83866744776507,4.349649048361027 50.83867719528296,4.349719753064413 50.838683073625454,4.349791 50.83868503805629,4.349862246935586 50.838683073625454,4.349932951638972 50.83867719528296,4.350002576004673 50.83866744776507,4.350070590149224 50.83865390525388,4.35013647644392 50.83863667081285,4.350199733454273 50.83861587560246,4.35025987975624 50.83859167788216,4.350316457600143 50.838564261806106,4.350369036394429 50.83853383602169,4.350417215982727 50.83850063208188,4.350460629689276 50.838464902683036,4.350498947109555 50.838426919742005,4.350531876624862 50.83838697232676,4.3505591676217 50.8383453644566,4.350580612399103 50.83830241278854,4.350596047749369 50.838258444207455,4.350605356200161 50.838213793338404,4.350608466908548 50.838168800000005))" +85,"POLYGON((4.329963042491753 50.89382979999999,4.329303173760741 50.89173728184793,4.327424026600278 50.88996325698214,4.324611684131032 50.888777853806836,4.321294299999999 50.88836158841073,4.317976915868966 50.888777853806836,4.31516457339972 50.88996325698214,4.313285426239258 50.89173728184793,4.312625557508246 50.89382979999999,4.313285426239258 50.895922224140264,4.31516457339972 50.897696022041536,4.317976915868966 50.89888119825232,4.321294299999999 50.89929736963664,4.324611684131032 50.89888119825232,4.327424026600278 50.897696022041536,4.329303173760741 50.895922224140264,4.329963042491753 50.89382979999999))" +86,"POLYGON((4.377184512035261 50.87098710000001,4.3761245 50.87031815478948,4.375064487964739 50.87098710000001,4.3761245 50.87165603561023,4.377184512035261 50.87098710000001))" +87,"POLYGON((4.453895340203068 50.888619,4.453877189984272 50.88829841447857,4.453822831817242 50.88797946039797,4.453732542698734 50.88766376312528,4.453606782721401 50.88735293146389,4.453446192729262 50.88704854945378,4.453251591052104 50.88675216829734,4.453023969335469 50.886465298451874,4.452764487487449 50.88618940192928,4.452474467768062 50.88592588484213,4.452155388051321 50.885676090234206,4.451808874294322 50.885441291232176,4.451436692251743 50.885222684553334,4.45104073847796 50.885021384402584,4.450623030662645 50.884838416790004,4.450185697349078 50.884674714297674,4.449730967087578 50.88453111132314,4.449261157079324 50.88440833982317,4.448778661368429 50.88430702558004,4.448285938642436 50.88422768500936,4.447785499703416 50.884170722525596,4.447279894673493 50.88413642847897,4.4467717 50.884124977674254,4.446263505326508 50.88413642847897,4.445757900296583 50.884170722525596,4.445257461357564 50.88422768500936,4.444764738631571 50.88430702558004,4.444282242920675 50.88440833982317,4.443812432912421 50.88453111132314,4.443357702650922 50.884674714297674,4.442920369337354 50.884838416790004,4.442502661522039 50.885021384402584,4.442106707748257 50.885222684553334,4.441734525705678 50.885441291232176,4.441388011948678 50.885676090234206,4.441068932231937 50.88592588484213,4.44077891251255 50.88618940192928,4.440519430664531 50.886465298451874,4.440291808947896 50.88675216829734,4.440097207270738 50.88704854945378,4.439936617278598 50.88735293146389,4.439810857301266 50.88766376312528,4.439720568182758 50.88797946039797,4.439666210015726 50.88829841447857,4.439648059796932 50.888619,4.439666210015726 50.88893958331512,4.439720568182758 50.88925853082167,4.439810857301266 50.889574217286444,4.439936617278598 50.88988503412606,4.440097207270738 50.89018939760224,4.440291808947896 50.890485756889916,4.440519430664531 50.890772601976956,4.44077891251255 50.89104847135548,4.441068932231937 50.89131195946548,4.441388011948678 50.89156172385307,4.441734525705678 50.8917964920068,4.442106707748257 50.892015067837335,4.442502661522039 50.892216337767735,4.442920369337354 50.89239927640319,4.443357702650922 50.892562951751444,4.443812432912421 50.892706529967555,4.444282242920675 50.89282927959876,4.444764738631571 50.89293057530796,4.445257461357564 50.89300990105686,4.445757900296583 50.89306685273271,4.446263505326508 50.8931011402053,4.4467717 50.893112588803696,4.447279894673493 50.8931011402053,4.447785499703416 50.89306685273271,4.448285938642436 50.89300990105686,4.448778661368429 50.89293057530796,4.449261157079324 50.89282927959876,4.449730967087578 50.892706529967555,4.450185697349078 50.892562951751444,4.450623030662645 50.89239927640319,4.45104073847796 50.892216337767735,4.451436692251743 50.892015067837335,4.451808874294322 50.8917964920068,4.452155388051321 50.89156172385307,4.452474467768062 50.89131195946548,4.452764487487449 50.89104847135548,4.453023969335469 50.890772601976956,4.453251591052104 50.890485756889916,4.453446192729262 50.89018939760224,4.453606782721401 50.88988503412606,4.453732542698734 50.889574217286444,4.453822831817242 50.88925853082167,4.453877189984272 50.88893958331512,4.453895340203068 50.888619))" +88,"POLYGON((4.234925554638761 50.80614320000001,4.234917826015505 50.805987785981266,4.234894670647086 50.80583298479672,4.234856179917162 50.80567940738504,4.23480250573106 50.80552765986116,4.234733859916271 50.805378341123934,4.234650513386465 50.80523204049231,4.234552795072317 50.80508933537904,4.23444109062337 50.804950789011514,4.234315840886053 50.80481694820831,4.234177540163855 50.80468834122061,4.234026734266544 50.804565475646704,4.233864018356101 50.80444883642801,4.233690034597886 50.804338883934534,4.233505469626307 50.8042360521472,4.233311051834987 50.80414074694443,4.233107548502127 50.80405334449942,4.232895762762411 50.803974189794985,4.232676530437397 50.80390359526122,4.232450716736914 50.803841839541874,4.232219212844474 50.80378916639404,4.231982932400177 50.80374578372564,4.231742807894989 50.80371186277427,4.231499786990631 50.80368753743119,4.231254828779584 50.80367290371245,4.2310089 50.803668019379785,4.230762971220415 50.80367290371245,4.230518013009369 50.80368753743119,4.23027499210501 50.80371186277427,4.230034867599823 50.80374578372564,4.229798587155525 50.80378916639404,4.229567083263086 50.803841839541874,4.229341269562603 50.80390359526122,4.229122037237589 50.803974189794985,4.228910251497873 50.80405334449942,4.228706748165013 50.80414074694443,4.228512330373692 50.8042360521472,4.228327765402114 50.804338883934534,4.228153781643899 50.80444883642801,4.227991065733455 50.804565475646704,4.227840259836145 50.80468834122061,4.227701959113947 50.80481694820831,4.227576709376629 50.804950789011514,4.227465004927682 50.80508933537904,4.227367286613534 50.80523204049231,4.227283940083728 50.805378341123934,4.227215294268939 50.80552765986116,4.227161620082837 50.80567940738504,4.227123129352914 50.80583298479672,4.227099973984494 50.805987785981266,4.227092245361239 50.80614320000001,4.227099973984494 50.80629861350175,4.227123129352914 50.806453413143466,4.227161620082837 50.806606988010806,4.227215294268939 50.806758732028996,4.227283940083728 50.80690804635442,4.227367286613534 50.807054341737754,4.227465004927682 50.80719704084897,4.227576709376629 50.80733558055537,4.227701959113947 50.807469414143384,4.227840259836145 50.80759801347566,4.227991065733455 50.807720871074636,4.228153781643899 50.807837502124634,4.228327765402114 50.807947446384496,4.228512330373692 50.808050270003115,4.228706748165013 50.80814556723096,4.228910251497873 50.80823296202053,4.229122037237589 50.80831210950981,4.229341269562603 50.808382697382434,4.229567083263086 50.808444447099724,4.229798587155525 50.80849711499924,4.230034867599823 50.80854049325586,4.23027499210501 50.80857441070152,4.230518013009369 50.808598733500276,4.230762971220415 50.80861336567618,4.2310089 50.80861824949187,4.231254828779584 50.80861336567618,4.231499786990631 50.808598733500276,4.231742807894989 50.80857441070152,4.231982932400177 50.80854049325586,4.232219212844474 50.80849711499924,4.232450716736914 50.808444447099724,4.232676530437397 50.808382697382434,4.232895762762411 50.80831210950981,4.233107548502127 50.80823296202053,4.233311051834987 50.80814556723096,4.233505469626307 50.808050270003115,4.233690034597886 50.807947446384496,4.233864018356101 50.807837502124634,4.234026734266544 50.807720871074636,4.234177540163855 50.80759801347566,4.234315840886053 50.807469414143384,4.23444109062337 50.80733558055537,4.234552795072317 50.80719704084897,4.234650513386465 50.807054341737754,4.234733859916271 50.80690804635442,4.23480250573106 50.806758732028996,4.234856179917162 50.806606988010806,4.234894670647086 50.806453413143466,4.234917826015505 50.80629861350175,4.234925554638761 50.80614320000001))" +89,"POLYGON((4.46832687004566 50.907520799999986,4.468261036454494 50.90694036954417,4.468064875863062 50.906371747960854,4.467742381535326 50.90582651138642,4.467300118525804 50.905315760275144,4.466747090033985 50.904849893344256,4.466094554125163 50.90443839578084,4.465355794548682 50.90408964603098,4.464545850319111 50.903810745113724,4.463681209565281 50.90360737194494,4.462779473879521 50.90348366762593,4.461858999999999 50.903442151060574,4.460938526120478 50.90348366762593,4.460036790434716 50.90360737194494,4.459172149680887 50.903810745113724,4.458362205451317 50.90408964603098,4.457623445874835 50.90443839578084,4.456970909966012 50.904849893344256,4.456417881474194 50.905315760275144,4.455975618464671 50.90582651138642,4.455653124136936 50.906371747960854,4.455456963545505 50.90694036954417,4.455391129954338 50.907520799999986,4.455456963545505 50.908101223218615,4.455653124136936 50.90866982367666,4.455975618464671 50.909215026949184,4.456417881474194 50.909725735279835,4.456970909966012 50.910191553417235,4.457623445874835 50.91060300012722,4.458362205451317 50.91095170108359,4.459172149680887 50.911230559220236,4.460036790434716 50.9114338990871,4.460938526120478 50.91155758228086,4.461858999999999 50.91159909160901,4.462779473879521 50.91155758228086,4.463681209565281 50.9114338990871,4.464545850319111 50.911230559220236,4.465355794548682 50.91095170108359,4.466094554125163 50.91060300012722,4.466747090033985 50.910191553417235,4.467300118525804 50.909725735279835,4.467742381535326 50.909215026949184,4.468064875863062 50.90866982367666,4.468261036454494 50.908101223218615,4.46832687004566 50.907520799999986))" +90,"POLYGON((4.457930726839294 50.83930599999999,4.457902107514245 50.83905330529584,4.457816832146026 50.838805753400266,4.457676636695218 50.838568383877124,4.457484375136913 50.83834602907634,4.457243961361996 50.83814321574578,4.456960289501633 50.83796407285978,4.456639134296858 50.837812247542516,4.456287033541503 50.83769083079943,4.455911154991574 50.83760229457058,4.455519150450402 50.837548441389245,4.455119 50.837530367672045,4.454718849549597 50.837548441389245,4.454326845008426 50.83760229457058,4.453950966458497 50.83769083079943,4.453598865703142 50.837812247542516,4.453277710498366 50.83796407285978,4.452994038638003 50.83814321574578,4.452753624863087 50.83834602907634,4.452561363304781 50.838568383877124,4.452421167853974 50.838805753400266,4.452335892485754 50.83905330529584,4.452307273160706 50.83930599999999,4.452335892485754 50.83955869333575,4.452421167853974 50.83980624123703,4.452561363304781 50.840043604463546,4.452753624863087 50.8402659511755,4.452994038638003 50.84046875528034,4.453277710498366 50.84064788855112,4.453598865703142 50.84079970464265,4.453950966458497 50.840921113296915,4.454326845008426 50.841009643229135,4.454718849549597 50.841063492416154,4.455119 50.84108156476498,4.455519150450402 50.841063492416154,4.455911154991574 50.841009643229135,4.456287033541503 50.840921113296915,4.456639134296858 50.84079970464265,4.456960289501633 50.84064788855112,4.457243961361996 50.84046875528034,4.457484375136913 50.8402659511755,4.457676636695218 50.840043604463546,4.457816832146026 50.83980624123703,4.457902107514245 50.83955869333575,4.457930726839294 50.83930599999999))" +91,"POLYGON((4.229430515295152 50.844659199999995,4.229303457743551 50.84374218847062,4.228926145668161 50.842853022661906,4.228310043505462 50.842018721768255,4.227473871207904 50.84126463918727,4.226443035447626 50.84061369173691,4.225248857647576 50.840085662808825,4.223927622295926 50.839696600695184,4.222519474460257 50.83945833043872,4.221067199999999 50.83937809410201,4.219614925539743 50.83945833043872,4.218206777704073 50.839696600695184,4.216885542352423 50.840085662808825,4.215691364552374 50.84061369173691,4.214660528792096 50.84126463918727,4.213824356494539 50.842018721768255,4.213208254331839 50.842853022661906,4.212830942256448 50.84374218847062,4.212703884704848 50.844659199999995,4.212830942256448 50.84557619350572,4.213208254331839 50.84646530741737,4.213824356494539 50.84729952880009,4.214660528792096 50.84805351384649,4.215691364552374 50.84870435750272,4.216885542352423 50.84923228889622,4.218206777704073 50.84962127149893,4.219614925539743 50.84985948985833,4.221067199999999 50.849939708171384,4.222519474460257 50.84985948985833,4.223927622295926 50.84962127149893,4.225248857647576 50.84923228889622,4.226443035447626 50.84870435750272,4.227473871207904 50.84805351384649,4.228310043505462 50.84729952880009,4.228926145668161 50.84646530741737,4.229303457743551 50.84557619350572,4.229430515295152 50.844659199999995))" +92,"POLYGON((4.456239701574073 50.86763260000001,4.456191888546268 50.86713373723634,4.456049146684468 50.86664214379283,4.455813557486442 50.8661649885507,4.455488556373198 50.865709230055494,4.455078882592807 50.8652815150139,4.454590510111491 50.864888081328,4.454030560499749 50.864534667082886,4.453407199083815 50.86422642681814,4.452729515876819 50.863967856306964,4.452007393025933 50.863762726943285,4.451251360708399 50.86361403069676,4.450472443577843 50.86352393644115,4.449682 50.863493758295434,4.448891556422156 50.86352393644115,4.448112639291601 50.86361403069676,4.447356606974068 50.863762726943285,4.446634484123181 50.863967856306964,4.445956800916186 50.86422642681814,4.445333439500251 50.864534667082886,4.444773489888509 50.864888081328,4.444285117407193 50.8652815150139,4.443875443626802 50.865709230055494,4.443550442513558 50.8661649885507,4.443314853315533 50.86664214379283,4.443172111453732 50.86713373723634,4.443124298425928 50.86763260000001,4.443172111453732 50.86813145742523,4.443314853315533 50.86862303516363,4.443550442513558 50.86910016524673,4.443875443626802 50.86955589059114,4.444285117407193 50.86998356641677,4.444773489888509 50.87037695710062,4.445333439500251 50.87073032705672,4.445956800916186 50.87103852431941,4.446634484123181 50.871297055614626,4.447356606974068 50.8715021518275,4.448112639291601 50.871650822914994,4.448891556422156 50.871740901465515,4.449682 50.871771074272765,4.450472443577843 50.871740901465515,4.451251360708399 50.871650822914994,4.452007393025933 50.8715021518275,4.452729515876819 50.871297055614626,4.453407199083815 50.87103852431941,4.454030560499749 50.87073032705672,4.454590510111491 50.87037695710062,4.455078882592807 50.86998356641677,4.455488556373198 50.86955589059114,4.455813557486442 50.86910016524673,4.456049146684468 50.86862303516363,4.456191888546268 50.86813145742523,4.456239701574073 50.86763260000001))" +93,"POLYGON((4.356123401931379 50.8247516,4.352072 50.82219228165979,4.348020598068621 50.8247516,4.352072 50.827310778052826,4.356123401931379 50.8247516))" +94,"POLYGON((4.307933833459792 50.85837579999999,4.3037926 50.85576161691041,4.29965136654021 50.85837579999999,4.3037926 50.86098983654764,4.307933833459792 50.85837579999999))" +95,"POLYGON((4.297091885932646 50.81352789999999,4.297060813032385 50.813078221391336,4.296967830815132 50.81263196082837,4.296813646931708 50.812192514769826,4.296599434814563 50.81176322790458,4.296326824747253 50.811347367689315,4.295997891456996 50.81094809947133,4.295615138324749 50.81056846238618,4.295181478332958 50.810211346213954,4.294700211896013 50.8098794693707,4.294175001742096 50.8095753582031,4.293609845037609 50.80930132774422,4.293009042966323 50.80905946407771,4.292377167994775 50.808851608444776,4.291719029073036 50.808679343215594,4.291039635035694 50.80854397983258,4.290344156481604 50.808446548817265,4.289637886422504 50.80838779191753,4.2889262 50.80836815645528,4.288214513577495 50.80838779191753,4.287508243518395 50.808446548817265,4.286812764964305 50.80854397983258,4.286133370926963 50.808679343215594,4.285475232005224 50.808851608444776,4.284843357033676 50.80905946407771,4.284242554962391 50.80930132774422,4.283677398257903 50.8095753582031,4.283152188103985 50.8098794693707,4.282670921667041 50.810211346213954,4.282237261675251 50.81056846238618,4.281854508543002 50.81094809947133,4.281525575252746 50.811347367689315,4.281252965185436 50.81176322790458,4.281038753068291 50.812192514769826,4.280884569184867 50.81263196082837,4.280791586967615 50.813078221391336,4.280760514067353 50.81352789999999,4.280791586967615 50.813977574279335,4.280884569184867 50.81442382198586,4.281038753068291 50.81486324705149,4.281252965185436 50.81529250542521,4.281525575252746 50.81570833051604,4.281854508543002 50.81610755804392,4.282237261675251 50.81648715010963,4.282670921667041 50.81684421830098,4.283152188103985 50.8171760456598,4.283677398257903 50.817480107342966,4.284242554962391 50.817754089820966,4.284843357033676 50.81799590846803,4.285475232005224 50.81820372341087,4.286133370926963 50.8183759535156,4.286812764964305 50.81851128840709,4.287508243518395 50.8186086984295,4.288214513577495 50.818667442472794,4.2889262 50.81868707360572,4.289637886422504 50.818667442472794,4.290344156481604 50.8186086984295,4.291039635035694 50.81851128840709,4.291719029073036 50.8183759535156,4.292377167994775 50.81820372341087,4.293009042966323 50.81799590846803,4.293609845037609 50.817754089820966,4.294175001742096 50.817480107342966,4.294700211896013 50.8171760456598,4.295181478332958 50.81684421830098,4.295615138324749 50.81648715010963,4.295997891456996 50.81610755804392,4.296326824747253 50.81570833051604,4.296599434814563 50.81529250542521,4.296813646931708 50.81486324705149,4.296967830815132 50.81442382198586,4.297060813032385 50.813977574279335,4.297091885932646 50.81352789999999))" +96,"POLYGON((4.318542453321281 50.8857422,4.318521739641572 50.88537631354943,4.318459704154606 50.88501228872067,4.318356662979008 50.8846519805661,4.318213141188988 50.88429722524093,4.31802987013869 50.88394983064426,4.317807783735376 50.883611567203516,4.317548013680453 50.883284158849015,4.317251883702574 50.88296927422474,4.316920902812227 50.88266851818033,4.316556757612163 50.88238342358764,4.316161303702851 50.8821154435237,4.315736556226768 50.8818659438601,4.31528467959969 50.88163619629652,4.31480797648133 50.88142737187423,4.314308876041508 50.881240535002625,4.313789921581662 50.88107663802936,4.313253757574764 50.8809365163819,4.312703116189695 50.88082088430539,4.312140803368732 50.88073033121863,4.31156968452912 50.880665318706654,4.310992669961551 50.88062617816577,4.3104127 50.88061310911253,4.309832730038448 50.88062617816577,4.30925571547088 50.880665318706654,4.308684596631268 50.88073033121863,4.308122283810305 50.88082088430539,4.307571642425234 50.8809365163819,4.307035478418337 50.88107663802936,4.306516523958491 50.881240535002625,4.30601742351867 50.88142737187423,4.305540720400309 50.88163619629652,4.30508884377323 50.8818659438601,4.304664096297147 50.8821154435237,4.304268642387836 50.88238342358764,4.303904497187771 50.88266851818033,4.303573516297425 50.88296927422474,4.303277386319546 50.883284158849015,4.303017616264622 50.883611567203516,4.302795529861308 50.88394983064426,4.302612258811011 50.88429722524093,4.30246873702099 50.8846519805661,4.302365695845392 50.88501228872067,4.302303660358428 50.88537631354943,4.302282946678718 50.8857422,4.302303660358428 50.88610808357696,4.302365695845392 50.886472099843424,4.30246873702099 50.88683239392125,4.302612258811011 50.88718712994184,4.302795529861308 50.88753450039907,4.303017616264622 50.88787273535691,4.303277386319546 50.88820011146487,4.303573516297425 50.888514960735456,4.303904497187771 50.888815679038686,4.304268642387836 50.889100734271025,4.304664096297147 50.88936867415669,4.30508884377323 50.88961813364202,4.305540720400309 50.889847841845246,4.30601742351867 50.890056628526345,4.306516523958491 50.89024343004424,4.307035478418337 50.890407294770995,4.307571642425234 50.89054738793554,4.308122283810305 50.890662995872596,4.308684596631268 50.890753529654795,4.30925571547088 50.89081852809004,4.309832730038448 50.89085766006859,4.3104127 50.89087072624823,4.310992669961551 50.89085766006859,4.31156968452912 50.89081852809004,4.312140803368732 50.890753529654795,4.312703116189695 50.890662995872596,4.313253757574764 50.89054738793554,4.313789921581662 50.890407294770995,4.314308876041508 50.89024343004424,4.31480797648133 50.890056628526345,4.31528467959969 50.889847841845246,4.315736556226768 50.88961813364202,4.316161303702851 50.88936867415669,4.316556757612163 50.889100734271025,4.316920902812227 50.888815679038686,4.317251883702574 50.888514960735456,4.317548013680453 50.88820011146487,4.317807783735376 50.88787273535691,4.31802987013869 50.88753450039907,4.318213141188988 50.88718712994184,4.318356662979008 50.88683239392125,4.318459704154606 50.886472099843424,4.318521739641572 50.88610808357696,4.318542453321281 50.8857422))" +97,"POLYGON((4.296320910349442 50.7920314,4.296319836478695 50.792014987316,4.296316622202079 50.791998686741564,4.296311289476363 50.79198260962633,4.296303874729471 50.79196686579357,4.296294428611644 50.79195156279003,4.296283015649442 50.791936805151224,4.296269713804971 50.79192269368734,4.296254613943318 50.79190932479462,4.296237819211847 50.79189678979683,4.296219444335605 50.79188517432143,4.296199614833628 50.7918745577146,4.296178466161521 50.791865012499215,4.29615614278616 50.79185660387948,4.296132797198834 50.7918493892954,4.296108588873577 50.79184341803048,4.296083683177795 50.79183873087499,4.296058250242646 50.79183535984735,4.296032463800866 50.79183332797536,4.2960065 50.79183264913897,4.295980536199133 50.79183332797536,4.295954749757354 50.79183535984735,4.295929316822205 50.79183873087499,4.295904411126424 50.79184341803048,4.295880202801166 50.7918493892954,4.29585685721384 50.79185660387948,4.295834533838478 50.791865012499215,4.295813385166372 50.7918745577146,4.295793555664395 50.79188517432143,4.295775180788152 50.79189678979683,4.295758386056682 50.79190932479462,4.295743286195028 50.79192269368734,4.295729984350558 50.791936805151224,4.295718571388357 50.79195156279003,4.295709125270529 50.79196686579357,4.295701710523638 50.79198260962633,4.295696377797921 50.791998686741564,4.295693163521305 50.792014987316,4.295692089650558 50.7920314,4.295693163521305 50.79204781267824,4.295696377797921 50.792064113235554,4.295701710523638 50.79208019032275,4.295709125270529 50.79209593411734,4.295718571388357 50.79211123707361,4.295729984350558 50.792125994657354,4.295743286195028 50.792140106059854,4.295758386056682 50.792153474886575,4.295775180788152 50.792166009815524,4.295793555664395 50.79217762522115,4.295813385166372 50.79218824175914,4.295834533838478 50.792197786908524,4.29585685721384 50.79220619546687,4.295880202801166 50.792213409995874,4.295904411126424 50.792219381213535,4.295929316822205 50.79222406833086,4.295954749757354 50.79222743933047,4.295980536199133 50.79222947118532,4.2960065 50.79223015001595,4.296032463800866 50.79222947118532,4.296058250242646 50.79222743933047,4.296083683177795 50.79222406833086,4.296108588873577 50.792219381213535,4.296132797198834 50.792213409995874,4.29615614278616 50.79220619546687,4.296178466161521 50.792197786908524,4.296199614833628 50.79218824175914,4.296219444335605 50.79217762522115,4.296237819211847 50.792166009815524,4.296254613943318 50.792153474886575,4.296269713804971 50.792140106059854,4.296283015649442 50.792125994657354,4.296294428611644 50.79211123707361,4.296303874729471 50.79209593411734,4.296311289476363 50.79208019032275,4.296316622202079 50.792064113235554,4.296319836478695 50.79204781267824,4.296320910349442 50.7920314))" +98,"POLYGON((4.40942693972298 50.83269699999999,4.4014499 50.8276585337954,4.393472860277019 50.83269699999999,4.4014499 50.83773492237023,4.40942693972298 50.83269699999999))" +99,"POLYGON((4.26234476234221 50.848410799999996,4.262090634934873 50.84739775063077,4.261353128474101 50.84648384671733,4.260204435230785 50.845758555723066,4.258756997302996 50.84529288429603,4.2571525 50.845132423781,4.255548002697004 50.84529288429603,4.254100564769214 50.845758555723066,4.252951871525898 50.84648384671733,4.252214365065126 50.84739775063077,4.251960237657789 50.848410799999996,4.252214365065126 50.84942382736978,4.252951871525898 50.8503376736879,4.254100564769214 50.85106289349045,4.255548002697004 50.851528507322165,4.2571525 50.85168894583774,4.258756997302996 50.851528507322165,4.260204435230785 50.85106289349045,4.261353128474101 50.8503376736879,4.262090634934873 50.84942382736978,4.26234476234221 50.848410799999996))" +100,"POLYGON((4.348419122384702 50.8766587,4.348410480305229 50.87656159877458,4.348384662745974 50.876465718454895,4.348341994377723 50.87637226480279,4.348283011779965 50.87628241307023,4.348208456693088 50.87619729321889,4.348119266690569 50.87611797570903,4.348016563388438 50.87604545803639,4.347901638340308 50.875980652186506,4.347775936795342 50.87592437316429,4.347641039523402 50.87587732874312,4.34749864293595 50.87584011056265,4.347350537752694 50.87581318668707,4.347198586482247 50.87579689571782,4.3470447 50.87579144253449,4.346890813517752 50.87579689571782,4.346738862247305 50.87581318668707,4.34659075706405 50.87584011056265,4.346448360476598 50.87587732874312,4.346313463204657 50.87592437316429,4.346187761659691 50.875980652186506,4.346072836611562 50.87604545803639,4.34597013330943 50.87611797570903,4.345880943306911 50.87619729321889,4.345806388220034 50.87628241307023,4.345747405622276 50.87637226480279,4.345704737254025 50.876465718454895,4.34567891969477 50.87656159877458,4.345670277615296 50.8766587,4.34567891969477 50.87675580102309,4.345704737254025 50.87685168074595,4.345747405622276 50.87694513343667,4.345806388220034 50.877034983891456,4.345880943306911 50.87712010221273,4.34597013330943 50.87719941801698,4.346072836611562 50.877271933893944,4.346187761659691 50.877336737948156,4.346313463204657 50.877393015264744,4.346448360476598 50.877440058155855,4.34659075706405 50.87747727505856,4.346738862247305 50.87750419797273,4.346890813517752 50.877520488345176,4.3470447 50.877525941326184,4.347198586482247 50.877520488345176,4.347350537752694 50.87750419797273,4.34749864293595 50.87747727505856,4.347641039523402 50.877440058155855,4.347775936795342 50.877393015264744,4.347901638340308 50.877336737948156,4.348016563388438 50.877271933893944,4.348119266690569 50.87719941801698,4.348208456693088 50.87712010221273,4.348283011779965 50.877034983891456,4.348341994377723 50.87694513343667,4.348384662745974 50.87685168074595,4.348410480305229 50.87675580102309,4.348419122384702 50.8766587))" diff --git a/berlinmod/data/vehicles.csv b/berlinmod/data/vehicles.csv new file mode 100644 index 00000000..61f2b1f2 --- /dev/null +++ b/berlinmod/data/vehicles.csv @@ -0,0 +1,142 @@ +vehid,licence,type,model +1,B-EF 1,passenger,Sachsenring +2,B-OU 2,passenger,Multicar +3,B-UM 3,passenger,Acabion +4,B-CK 4,passenger,Multicar +5,B-QZ 5,passenger,Acabion +6,B-ZY 6,passenger,Acabion +7,B-ZN 7,passenger,Volkswagen +8,B-DJ 8,passenger,Volkswagen +9,B-OM 9,passenger,Mercedes-Benz +10,B-DD 10,passenger,Porsche +11,B-NU 11,passenger,Audi +12,B-IG 12,passenger,BMW +13,B-OT 13,passenger,Mercedes-Benz +14,B-KH 14,passenger,Multicar +15,B-PZ 15,bus,Wartburg +16,B-YT 16,passenger,Sachsenring +17,B-CJ 17,truck,Opel +18,B-YY 18,passenger,Borgward +19,B-WZ 19,passenger,Opel +20,B-DB 20,passenger,Multicar +21,B-PI 21,passenger,Maybach +22,B-TK 22,passenger,Porsche +23,B-LW 23,passenger,Sachsenring +24,B-MF 24,truck,Multicar +25,B-TR 25,passenger,Acabion +26,B-DB 26,passenger,Porsche +27,B-IZ 27,bus,Maybach +28,B-EP 28,truck,Borgward +29,B-FT 29,passenger,Wartburg +30,B-ZT 30,passenger,Multicar +31,B-LZ 31,truck,Mercedes-Benz +32,B-ZE 32,passenger,Porsche +33,B-ND 33,passenger,Sachsenring +34,B-QB 34,passenger,BMW +35,B-KO 35,passenger,Mercedes-Benz +36,B-OE 36,passenger,BMW +37,B-WH 37,passenger,Borgward +38,B-QF 38,truck,Maybach +39,B-IS 39,passenger,Mercedes-Benz +40,B-LG 40,passenger,Mercedes-Benz +41,B-MU 41,passenger,Borgward +42,B-DG 42,passenger,Multicar +43,B-OC 43,passenger,Audi +44,B-BH 44,truck,Borgward +45,B-XL 45,passenger,Wartburg +46,B-OV 46,passenger,Wartburg +47,B-WC 47,passenger,Audi +48,B-OU 48,passenger,Wartburg +49,B-LY 49,passenger,Volkswagen +50,B-BY 50,truck,Audi +51,B-CR 51,truck,Mercedes-Benz +52,B-HX 52,passenger,BMW +53,B-UG 53,passenger,Borgward +54,B-TY 54,truck,Multicar +55,B-WH 55,passenger,Wartburg +56,B-FF 56,passenger,Sachsenring +57,B-QI 57,passenger,Borgward +58,B-QW 58,passenger,Wartburg +59,B-QV 59,passenger,Mercedes-Benz +60,B-KI 60,passenger,Borgward +61,B-LL 61,passenger,Multicar +62,B-EM 62,passenger,Opel +63,B-RJ 63,passenger,Opel +64,B-OG 64,passenger,Maybach +65,B-MG 65,passenger,Audi +66,B-GI 66,passenger,Audi +67,B-XD 67,bus,Acabion +68,B-TQ 68,passenger,Sachsenring +69,B-RO 69,passenger,Mercedes-Benz +70,B-XU 70,passenger,Mercedes-Benz +71,B-LE 71,passenger,Acabion +72,B-QO 72,passenger,Audi +73,B-IY 73,passenger,Acabion +74,B-IX 74,passenger,Acabion +75,B-CW 75,passenger,Multicar +76,B-JM 76,passenger,BMW +77,B-NP 77,bus,Multicar +78,B-ZL 78,truck,Sachsenring +79,B-UN 79,passenger,Porsche +80,B-HW 80,passenger,Audi +81,B-HQ 81,passenger,Audi +82,B-VM 82,passenger,Maybach +83,B-WE 83,passenger,Borgward +84,B-DP 84,passenger,Sachsenring +85,B-XQ 85,passenger,Mercedes-Benz +86,B-WG 86,passenger,Acabion +87,B-NO 87,truck,Acabion +88,B-ED 88,passenger,Mercedes-Benz +89,B-EU 89,passenger,Sachsenring +90,B-KM 90,passenger,BMW +91,B-WE 91,passenger,Borgward +92,B-RN 92,passenger,Opel +93,B-KD 93,passenger,Multicar +94,B-LC 94,passenger,Wartburg +95,B-MW 95,passenger,Maybach +96,B-UX 96,passenger,Volkswagen +97,B-LT 97,passenger,Maybach +98,B-[O 98,passenger,Volkswagen +99,B-[E 99,passenger,Porsche +100,B-KF 100,passenger,Volkswagen +101,B-MD 101,passenger,Multicar +102,B-PM 102,passenger,BMW +103,B-VQ 103,passenger,Wartburg +104,B-WI 104,truck,Borgward +105,B-ME 105,passenger,Multicar +106,B-XC 106,passenger,Maybach +107,B-[Y 107,passenger,Acabion +108,B-CR 108,passenger,Sachsenring +109,B-GK 109,passenger,Volkswagen +110,B-VS 110,passenger,Borgward +111,B-JU 111,passenger,Audi +112,B-[D 112,passenger,Porsche +113,B-XN 113,passenger,Sachsenring +114,B-FF 114,passenger,Volkswagen +115,B-BJ 115,passenger,Wartburg +116,B-IQ 116,passenger,Wartburg +117,B-JN 117,passenger,Volkswagen +118,B-RW 118,passenger,Porsche +119,B-JM 119,passenger,Porsche +120,B-YR 120,passenger,Porsche +121,B-IS 121,passenger,Volkswagen +122,B-TK 122,passenger,Mercedes-Benz +123,B-VD 123,passenger,Acabion +124,B-YF 124,passenger,Audi +125,B-BP 125,passenger,Mercedes-Benz +126,B-TD 126,passenger,Porsche +127,B-[J 127,passenger,Maybach +128,B-PL 128,passenger,Acabion +129,B-UO 129,passenger,Opel +130,B-ZS 130,passenger,Audi +131,B-NJ 131,passenger,Audi +132,B-NV 132,passenger,Porsche +133,B-FF 133,bus,Opel +134,B-ZL 134,passenger,Maybach +135,B-TN 135,passenger,Opel +136,B-SU 136,passenger,Sachsenring +137,B-WV 137,passenger,BMW +138,B-JP 138,passenger,Maybach +139,B-JV 139,passenger,Maybach +140,B-ZQ 140,passenger,Acabion +141,B-OD 141,passenger,Multicar diff --git a/berlinmod/expected/q01.csv b/berlinmod/expected/q01.csv new file mode 100644 index 00000000..f60e8daa --- /dev/null +++ b/berlinmod/expected/q01.csv @@ -0,0 +1,3 @@ +licence,model +B-AA 100,Sedan +B-CC 300,Lorry diff --git a/berlinmod/expected/q02.csv b/berlinmod/expected/q02.csv new file mode 100644 index 00000000..3c642294 --- /dev/null +++ b/berlinmod/expected/q02.csv @@ -0,0 +1,5 @@ +licence +B-AA 100 +B-BB 200 +B-CC 300 +B-DD 400 diff --git a/berlinmod/expected/q03.csv b/berlinmod/expected/q03.csv new file mode 100644 index 00000000..eec09de0 --- /dev/null +++ b/berlinmod/expected/q03.csv @@ -0,0 +1,3 @@ +vehid,licence,instantid,pos +1,B-AA 100,1,012E00010101000000000000000000494000000000000000000003A498073E0200 +3,B-CC 300,1,012E00010101000000000000000000494000000000000008400003A498073E0200 diff --git a/berlinmod/expected/q04.csv b/berlinmod/expected/q04.csv new file mode 100644 index 00000000..5720896c --- /dev/null +++ b/berlinmod/expected/q04.csv @@ -0,0 +1,3 @@ +licence +B-AA 100 +B-BB 200 diff --git a/berlinmod/expected/q05.csv b/berlinmod/expected/q05.csv new file mode 100644 index 00000000..9f4d11f1 --- /dev/null +++ b/berlinmod/expected/q05.csv @@ -0,0 +1,2 @@ +licence1,licence2,min_dist +B-AA 100,B-CC 300,3.0 diff --git a/berlinmod/expected/q06.csv b/berlinmod/expected/q06.csv new file mode 100644 index 00000000..4fe90fb5 --- /dev/null +++ b/berlinmod/expected/q06.csv @@ -0,0 +1,2 @@ +licence1,licence2 +B-CC 300,B-DD 400 diff --git a/berlinmod/expected/q07.csv b/berlinmod/expected/q07.csv new file mode 100644 index 00000000..da8f39b2 --- /dev/null +++ b/berlinmod/expected/q07.csv @@ -0,0 +1,3 @@ +vehid,licence,periodid,pos +1,B-AA 100,1,012E000E0200000003010100000000000000000034400000000000000000006EE98D073E020001010000000000000000005440000000000000000000985EA3073E0200 +3,B-CC 300,1,012E000E0200000003010100000000000000000034400000000000000840006EE98D073E020001010000000000000000005440000000000000084000985EA3073E0200 diff --git a/berlinmod/expected/q08.csv b/berlinmod/expected/q08.csv new file mode 100644 index 00000000..ab85f43d --- /dev/null +++ b/berlinmod/expected/q08.csv @@ -0,0 +1,6 @@ +tripid,traj +1,0102000000020000000000000000000000000000000000000000000000000059400000000000000000 +2,0102000000020000000000000000000000000000000000144000000000000059400000000000001440 +3,0102000000020000000000000000000000000000000000084000000000000059400000000000000840 +4,0102000000020000000000000000000000000000000000104000000000000059400000000000001040 +5,0102000000020000000000000000408F400000000000408F400000000000409F400000000000408F40 diff --git a/berlinmod/expected/q09.csv b/berlinmod/expected/q09.csv new file mode 100644 index 00000000..32eb2dde --- /dev/null +++ b/berlinmod/expected/q09.csv @@ -0,0 +1,2 @@ +periodId,period,maxDist +1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",600.000 diff --git a/berlinmod/expected/q10.csv b/berlinmod/expected/q10.csv new file mode 100644 index 00000000..2641d861 --- /dev/null +++ b/berlinmod/expected/q10.csv @@ -0,0 +1,5 @@ +licence1,car2Id,periods +B-AA 100,3,"{[2020-01-01 01:00:00+01, 2020-01-01 01:10:00+01]}" +B-CC 300,1,"{[2020-01-01 01:00:00+01, 2020-01-01 01:10:00+01]}" +B-CC 300,2,"{[2020-01-01 01:00:00+01, 2020-01-01 01:10:00+01]}" +B-CC 300,4,"{[2020-01-01 01:00:00+01, 2020-01-01 01:10:00+01]}" diff --git a/berlinmod/expected/q11.csv b/berlinmod/expected/q11.csv new file mode 100644 index 00000000..a84aa87f --- /dev/null +++ b/berlinmod/expected/q11.csv @@ -0,0 +1,3 @@ +pointId,geom,instantId,instant,licence +1,POINT(50 0),1,2020-01-01 01:05:00+01,B-AA 100 +2,POINT(50 5),1,2020-01-01 01:05:00+01,B-BB 200 diff --git a/berlinmod/expected/q12.csv b/berlinmod/expected/q12.csv new file mode 100644 index 00000000..adc56dc1 --- /dev/null +++ b/berlinmod/expected/q12.csv @@ -0,0 +1 @@ +pointId,geom,instantId,instant,licence1,licence2 diff --git a/berlinmod/expected/q13.csv b/berlinmod/expected/q13.csv new file mode 100644 index 00000000..199346aa --- /dev/null +++ b/berlinmod/expected/q13.csv @@ -0,0 +1,5 @@ +regionId,periodId,period,licence +1,1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-AA 100 +1,1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-BB 200 +1,1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-CC 300 +1,1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-DD 400 diff --git a/berlinmod/expected/q14.csv b/berlinmod/expected/q14.csv new file mode 100644 index 00000000..05cb9493 --- /dev/null +++ b/berlinmod/expected/q14.csv @@ -0,0 +1,5 @@ +regionId,instantId,instant,licence +1,1,2020-01-01 01:05:00+01,B-AA 100 +1,1,2020-01-01 01:05:00+01,B-BB 200 +1,1,2020-01-01 01:05:00+01,B-CC 300 +1,1,2020-01-01 01:05:00+01,B-DD 400 diff --git a/berlinmod/expected/q15.csv b/berlinmod/expected/q15.csv new file mode 100644 index 00000000..c3ff1376 --- /dev/null +++ b/berlinmod/expected/q15.csv @@ -0,0 +1,3 @@ +pointId,geom,periodId,period,licence +1,POINT(50 0),1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-AA 100 +2,POINT(50 5),1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",B-BB 200 diff --git a/berlinmod/expected/q16.csv b/berlinmod/expected/q16.csv new file mode 100644 index 00000000..caba2ade --- /dev/null +++ b/berlinmod/expected/q16.csv @@ -0,0 +1,2 @@ +periodId,period,regionId,licence1,licence2 +1,"[2020-01-01 01:02:00+01, 2020-01-01 01:08:00+01]",1,B-AA 100,B-CC 300 diff --git a/berlinmod/expected/q17.csv b/berlinmod/expected/q17.csv new file mode 100644 index 00000000..bc78509c --- /dev/null +++ b/berlinmod/expected/q17.csv @@ -0,0 +1,3 @@ +pointId,hits +1,1 +2,1 diff --git a/berlinmod/expected/qrt.csv b/berlinmod/expected/qrt.csv new file mode 100644 index 00000000..70d2a4b8 --- /dev/null +++ b/berlinmod/expected/qrt.csv @@ -0,0 +1,6 @@ +tripid,trip_hexwkb +1,012E000E02000000030101000000000000000000000000000000000000000060C286073E020001010000000000000000005940000000000000000000A685AA073E0200 +2,012E000E02000000030101000000000000000000000000000000000014400060C286073E020001010000000000000000005940000000000000144000A685AA073E0200 +3,012E000E02000000030101000000000000000000000000000000000008400060C286073E020001010000000000000000005940000000000000084000A685AA073E0200 +4,012E000E02000000030101000000000000000000000000000000000010400060C286073E020001010000000000000000005940000000000000104000A685AA073E0200 +5,012E000E020000000301010000000000000000408F400000000000408F400060C286073E020001010000000000000000409F400000000000408F4000A685AA073E0200 diff --git a/berlinmod/load_mbdb.sql b/berlinmod/load_mbdb.sql new file mode 100644 index 00000000..2b56a10e --- /dev/null +++ b/berlinmod/load_mbdb.sql @@ -0,0 +1,152 @@ +/****************************************************************************** + * BerlinMOD portable SQL — MobilityDB/PostgreSQL data loader + * + * Loads the shared berlinmod/data/ CSV files into a PostgreSQL database with + * the MobilityDB extension. Run via the companion shell script: + * + * ./berlinmod/run_mbdb.sh [dbname] + * + * Or manually (psql must be run from the repository root): + * + * psql -d \ + * -v v_csv=berlinmod/data/vehicles.csv \ + * -v t_csv=berlinmod/data/trips.csv \ + * -v ql_csv=berlinmod/data/query_licences.csv \ + * -v qi_csv=berlinmod/data/query_instants.csv \ + * -v qp_csv=berlinmod/data/query_points.csv \ + * -f berlinmod/load_mbdb.sql + ******************************************************************************/ + +CREATE EXTENSION IF NOT EXISTS MobilityDB CASCADE; + +------------------------------------------------------------------------------- +-- Drop and recreate all tables +------------------------------------------------------------------------------- + +DROP TABLE IF EXISTS QueryRegions CASCADE; +DROP TABLE IF EXISTS QueryPeriods CASCADE; +DROP TABLE IF EXISTS QueryPoints CASCADE; +DROP TABLE IF EXISTS QueryInstants CASCADE; +DROP TABLE IF EXISTS QueryLicences CASCADE; +DROP TABLE IF EXISTS Trips CASCADE; +DROP TABLE IF EXISTS Vehicles CASCADE; + +CREATE TABLE Vehicles ( + vehId INTEGER PRIMARY KEY, + licence TEXT NOT NULL, + type TEXT NOT NULL, + model TEXT NOT NULL +); + +CREATE TABLE Trips ( + tripId INTEGER PRIMARY KEY, + vehId INTEGER NOT NULL REFERENCES Vehicles(vehId), + trip tgeompoint NOT NULL, + trip_h3 th3index NOT NULL -- temporal H3-cell index, computed from trip +); + +CREATE TABLE QueryLicences ( + licenceId INTEGER PRIMARY KEY, + licence TEXT NOT NULL +); + +CREATE TABLE QueryInstants ( + instantId INTEGER PRIMARY KEY, + instant TIMESTAMPTZ NOT NULL +); + +CREATE TABLE QueryPoints ( + pointId INTEGER PRIMARY KEY, + geom geometry(Point,3857) NOT NULL +); + +CREATE TABLE QueryRegions ( + regionId INTEGER PRIMARY KEY, + geom geometry(Polygon,3857) NOT NULL +); + +CREATE TABLE QueryPeriods ( + periodId INTEGER PRIMARY KEY, + period tstzspan NOT NULL +); + +------------------------------------------------------------------------------- +-- Load non-temporal tables directly from CSV +-- Paths are substituted by run_mbdb.sh (DATADIR placeholder) +------------------------------------------------------------------------------- + +\copy Vehicles FROM 'DATADIR/vehicles.csv' DELIMITER ',' CSV HEADER +\copy QueryLicences FROM 'DATADIR/query_licences.csv' DELIMITER ',' CSV HEADER +\copy QueryInstants FROM 'DATADIR/query_instants.csv' DELIMITER ',' CSV HEADER + +------------------------------------------------------------------------------- +-- Load Trips: read EWKB hex text, convert to tgeompoint, and derive trip_h3. +-- +-- The CSV produced by berlinmod_portability_export() in MobilityDB-BerlinMOD +-- contains 4 columns (tripId, vehId, trip, trip_h3) but for backward +-- compatibility this loader reads only the first 3 (tripId, vehId, trip) +-- via TripsTmp's column list — psql's \copy ignores extra columns when an +-- explicit column list is supplied, so the loader works unchanged on either +-- the old 3-column or the new 4-column CSV. trip_h3 is then computed from +-- the loaded tgeompoint at the H3 resolution chosen below (default 7); this +-- guarantees a consistent resolution across all three benchmarked platforms +-- regardless of how the CSV was produced. +------------------------------------------------------------------------------- + +\set h3resolution 7 + +CREATE TEMP TABLE TripsTmp (tripId INTEGER, vehId INTEGER, trip TEXT); +\copy TripsTmp(tripId, vehId, trip) FROM 'DATADIR/trips.csv' DELIMITER ',' CSV HEADER +INSERT INTO Trips + SELECT tripId, vehId, + tgeompointfromhexewkb(trip) AS trip, + tgeompoint_to_th3index(tgeompointfromhexewkb(trip), :h3resolution) AS trip_h3 + FROM TripsTmp; +DROP TABLE TripsTmp; + +------------------------------------------------------------------------------- +-- Load QueryPoints: read WKT text, parse with ST_GeomFromText (SRID 0) +------------------------------------------------------------------------------- + +CREATE TEMP TABLE QueryPointsTmp (pointId INTEGER, geom TEXT); +\copy QueryPointsTmp FROM 'DATADIR/query_points.csv' DELIMITER ',' CSV HEADER +INSERT INTO QueryPoints SELECT pointId, ST_GeomFromText(geom, 3857) FROM QueryPointsTmp; +DROP TABLE QueryPointsTmp; + +------------------------------------------------------------------------------- +-- Load QueryRegions: read WKT text, parse polygon geometry +------------------------------------------------------------------------------- + +CREATE TEMP TABLE QueryRegionsTmp (regionId INTEGER, geom TEXT); +\copy QueryRegionsTmp FROM 'DATADIR/query_regions.csv' DELIMITER ',' CSV HEADER +INSERT INTO QueryRegions SELECT regionId, ST_GeomFromText(geom, 3857) FROM QueryRegionsTmp; +DROP TABLE QueryRegionsTmp; + +------------------------------------------------------------------------------- +-- Load QueryPeriods: read period text, cast to tstzspan +------------------------------------------------------------------------------- + +CREATE TEMP TABLE QueryPeriodsTmp (periodId INTEGER, period TEXT); +\copy QueryPeriodsTmp FROM 'DATADIR/query_periods.csv' DELIMITER ',' CSV HEADER +INSERT INTO QueryPeriods SELECT periodId, period::tstzspan FROM QueryPeriodsTmp; +DROP TABLE QueryPeriodsTmp; + +------------------------------------------------------------------------------- +-- GiST + SP-GiST indexes — the native PostgreSQL/MobilityDB analog of the +-- columnar prefilter the other two platforms rely on. GiST on trip is the +-- standard MobilityDB STBox-overlap index; GiST on trip_h3 accelerates the +-- th3index cell-membership predicate (everEqH3IndexTh3Index / +-- everEqTh3IndexTh3Index) used by the portable BerlinMOD SQL. SP-GiST on +-- trip is added as a complement — its kd-tree-style partitioning often +-- wins on tgeompoint when trip extents differ widely. +------------------------------------------------------------------------------- + +CREATE INDEX IF NOT EXISTS trips_trip_gist_idx ON Trips USING GIST (trip); +CREATE INDEX IF NOT EXISTS trips_trip_h3_gist_idx ON Trips USING GIST (trip_h3); +CREATE INDEX IF NOT EXISTS trips_trip_spgist_idx ON Trips USING SPGIST(trip); +CREATE INDEX IF NOT EXISTS qp_geom_gist_idx ON QueryPoints USING GIST (geom); +CREATE INDEX IF NOT EXISTS qr_geom_gist_idx ON QueryRegions USING GIST (geom); +CREATE INDEX IF NOT EXISTS qper_period_gist_idx ON QueryPeriods USING GIST (period); + +ANALYZE Vehicles, Trips, QueryLicences, QueryInstants, QueryPoints, + QueryRegions, QueryPeriods; diff --git a/berlinmod/load_mduck.sql b/berlinmod/load_mduck.sql new file mode 100644 index 00000000..18396ca3 --- /dev/null +++ b/berlinmod/load_mduck.sql @@ -0,0 +1,98 @@ +/****************************************************************************** + * BerlinMOD portable SQL — MobilityDuck/DuckDB data loader + * + * Loads the shared berlinmod/data/ CSV files into DuckDB using the + * MobilityDuck extension. Run from the repo root: + * + * duckdb :memory: -s ".read berlinmod/load_mduck.sql" + * + * Or pass DATADIR via substitution — DuckDB has no native \copy variables, + * so the paths below assume execution from the repository root (default). + * Change DATADIR in the first assignment if running from another directory. + ******************************************************************************/ + +-- Path to the CSV data files (relative to the working directory) +SET VARIABLE DATADIR = 'berlinmod/data/'; + +-- Match the Europe/Berlin timezone used when generating the expected output files +LOAD icu; +SET TimeZone = 'Europe/Berlin'; + +------------------------------------------------------------------------------- +-- Drop and recreate all tables +------------------------------------------------------------------------------- + +DROP TABLE IF EXISTS QueryRegions; +DROP TABLE IF EXISTS QueryPeriods; +DROP TABLE IF EXISTS QueryPoints; +DROP TABLE IF EXISTS QueryInstants; +DROP TABLE IF EXISTS QueryLicences; +DROP TABLE IF EXISTS Trips; +DROP TABLE IF EXISTS Vehicles; + +CREATE TABLE Vehicles AS + SELECT * FROM read_csv(getvariable('DATADIR') || 'vehicles.csv', header = true); + +CREATE TABLE QueryLicences AS + SELECT * FROM read_csv(getvariable('DATADIR') || 'query_licences.csv', header = true); + +CREATE TABLE QueryInstants AS + SELECT instantId, + CAST(instant AS TIMESTAMPTZ) AS instant + FROM read_csv(getvariable('DATADIR') || 'query_instants.csv', header = true); + +-- Trips: load raw text first, then convert to tgeompoint in a second pass. +-- DuckDB 1.4.x parallel read_csv does not invoke the scalar-function wrapper +-- that calls EnsureMeosInitializedOnThread(), so calling tgeompointFromHexWKB +-- inline in the SELECT causes a SIGSEGV on worker threads. Two-step loading +-- keeps the CSV scan (multi-threaded) separate from the MEOS conversion +-- (also multi-threaded but through the normal expression pipeline, which +-- does invoke the wrapper). +-- +-- The trip_h3 column is a temporal H3-cell index of the trip, used by the +-- portable BerlinMOD SQL as a spatial prefilter. We always recompute it +-- from the loaded tgeompoint at H3 resolution 7, so the column is consistent +-- across all three platforms regardless of whether the source CSV included +-- a precomputed trip_h3 column. read_csv's explicit columns parameter +-- reads only the first 3 columns (tripId, vehId, trip) and ignores any +-- extra header column. +CREATE TEMP TABLE TripsRaw AS + SELECT tripId, vehId, trip + FROM read_csv(getvariable('DATADIR') || 'trips.csv', + header = true, + columns = {'tripId': 'INTEGER', 'vehId': 'INTEGER', 'trip': 'VARCHAR'}); + +CREATE TABLE Trips AS + SELECT tripId, + vehId, + tgeompointFromHexWKB(trip) AS trip, + tgeompoint_to_th3index(tgeompointFromHexWKB(trip), 7) AS trip_h3 + FROM TripsRaw; + +-- QueryPoints: geometry for spatial ops + original WKT string for portable display +CREATE TABLE QueryPoints AS + SELECT pointId, + ST_GeomFromText(geom) AS geom, + geom AS geomWKT + FROM read_csv(getvariable('DATADIR') || 'query_points.csv', header = true); + +-- QueryRegions: cast the WKT polygon string to DuckDB geometry +CREATE TABLE QueryRegions AS + SELECT regionId, + ST_GeomFromText(geom) AS geom + FROM read_csv(getvariable('DATADIR') || 'query_regions.csv', header = true); + +-- QueryPeriods: cast the period string to tstzspan +CREATE TABLE QueryPeriods AS + SELECT periodId, + CAST(period AS tstzspan) AS period + FROM read_csv(getvariable('DATADIR') || 'query_periods.csv', header = true); + +-- portable schema — shadows trajectory() to return hex-WKB text instead of +-- GEOMETRY, so DuckDB COPY serializes it as a string (byte-for-byte identical +-- to MobilityDB and MobilitySpark). main.trajectory() is schema-qualified to +-- avoid macro recursion. run_mduck.sh inlines this file per query, so +-- SET search_path persists for each query's DuckDB session. +CREATE SCHEMA IF NOT EXISTS portable; +CREATE OR REPLACE MACRO portable.trajectory(t) AS ST_AsHexWKB(main.trajectory(t)); +SET search_path='portable,main'; diff --git a/berlinmod/q01.sql b/berlinmod/q01.sql new file mode 100644 index 00000000..ea8121a5 --- /dev/null +++ b/berlinmod/q01.sql @@ -0,0 +1,11 @@ +-- BerlinMOD Q1: Models of vehicles with licences from QueryLicences. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: none (pure relational join — baseline portability test). + +SELECT l.licence, v.model +FROM QueryLicences l +JOIN Vehicles v ON v.licence = l.licence +ORDER BY l.licence; diff --git a/berlinmod/q02.sql b/berlinmod/q02.sql new file mode 100644 index 00000000..7d38869d --- /dev/null +++ b/berlinmod/q02.sql @@ -0,0 +1,23 @@ +-- BerlinMOD Q2: Licence plates of vehicles that ever entered a query region. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- eIntersects(trip, geom) is true whenever the moving vehicle was inside +-- or on the boundary of the polygon at any instant. +-- +-- Spatial prefilter (th3index, polygon-side): geoToH3IndexSet covers the +-- query region with H3 cells at resolution 7; everIntersectsH3IndexSet_Th3Index +-- tests whether the trip's th3index path ever lies in any of those cells. +-- Sound for the eIntersects predicate at any resolution — a trip can only +-- intersect the region if it ever passes through a cell that covers part +-- of it. On MobilityDB the GiST index on Trips(trip_h3) accelerates the +-- prefilter; on DuckDB / Spark the column is the prefilter mechanism. + +SELECT DISTINCT v.licence +FROM Vehicles v +JOIN Trips t ON t.vehId = v.vehId +JOIN QueryRegions r ON + everIntersectsH3IndexSet_Th3Index(geoToH3IndexSet(r.geom, 7), t.trip_h3) + AND eIntersects(t.trip, r.geom) +ORDER BY v.licence; diff --git a/berlinmod/q03.sql b/berlinmod/q03.sql new file mode 100644 index 00000000..5634d5e0 --- /dev/null +++ b/berlinmod/q03.sql @@ -0,0 +1,21 @@ +-- BerlinMOD Q3: Position of query-licence vehicles at each query instant. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Output convention (binary return): +-- pos is the MEOS hex-WKB encoding of the tgeompoint instant, produced by +-- asHexWKB(). All three platforms call the same MEOS C function +-- (temporal_as_hexwkb, variant 0 = little-endian NDR) so the output is +-- byte-for-byte identical across platforms. + +SELECT v.vehId AS vehid, + v.licence, + i.instantId AS instantid, + asHexWKB(atTime(t.trip, i.instant)) AS pos +FROM QueryLicences l +JOIN Vehicles v ON v.licence = l.licence +JOIN Trips t ON t.vehId = v.vehId +JOIN QueryInstants i ON true +WHERE atTime(t.trip, i.instant) IS NOT NULL +ORDER BY v.vehId, i.instantId; diff --git a/berlinmod/q04.sql b/berlinmod/q04.sql new file mode 100644 index 00000000..af6be5c6 --- /dev/null +++ b/berlinmod/q04.sql @@ -0,0 +1,30 @@ +-- BerlinMOD Q4: Licence plates of vehicles that ever passed a query point. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- eIntersects(tgeompoint, geometry) → boolean, true if the trip ever intersects geom +-- +-- Spatial prefilter (th3index): the trip's th3index sequence (a temporal H3 +-- cell index, materialised as the trip_h3 column) must contain the query +-- point's H3 cell at the chosen resolution. This is a sound prefilter for +-- a point-geometry intersection at any H3 resolution — a trip can only +-- intersect a point if it ever passes through the point's cell. +-- +-- COALESCE(everEqH3IndexTh3Index(geomToH3Cell(p.geom, 7), t.trip_h3), TRUE) +-- +-- The COALESCE guards against non-POINT geometries (geomToH3Cell returns +-- NULL for those) — falls through to the exact eIntersects. +-- +-- MobilityDB operator equivalent: t.trip && p.geom (ever-intersects shorthand) +-- On PostgreSQL the GiST index on Trips(trip_h3) accelerates the prefilter; +-- on DuckDB / Spark the th3index column itself is the prefilter mechanism. + +SELECT DISTINCT v.licence +FROM Vehicles v +JOIN Trips t ON t.vehId = v.vehId +JOIN QueryPoints p ON + COALESCE(everEqH3IndexTh3Index(geomToH3Cell(p.geom, 7), t.trip_h3), TRUE) + AND eIntersects(t.trip, p.geom) +ORDER BY v.licence; diff --git a/berlinmod/q05.sql b/berlinmod/q05.sql new file mode 100644 index 00000000..ee283d07 --- /dev/null +++ b/berlinmod/q05.sql @@ -0,0 +1,37 @@ +-- BerlinMOD Q5: For each pair of query-licence vehicles, the minimum +-- spatial distance ever reached between their trips, irrespective of +-- time. The BerlinMOD spec asks for the minimum distance between the +-- places each vehicle has been; the answer is the spatial-min over the +-- two trajectories. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operation used: +-- minDistance(tgeompoint, tgeompoint) → float8 +-- Returns the minimum spatial distance reached at any pair of +-- points on the two trajectories, ignoring time. Distinct from +-- nearestApproachDistance, which is the time-synchronous variant. +-- +-- Spatial prefilter (th3index): trips whose th3index sequences never +-- agree on a cell at any common instant cannot reach a min distance +-- below the cell edge length at the chosen resolution. At the default +-- resolution 7 (cell edge approximately 1.2 km) the prefilter is sound +-- for distance thresholds well below that edge length; it excludes +-- only pairs whose true min distance is far above the thresholds that +-- BerlinMOD's tDwithin/eDwithin queries care about. +-- +-- everEqTh3IndexTh3Index(t1.trip_h3, t2.trip_h3) + +SELECT l1.licence AS licence1, + l2.licence AS licence2, + MIN(minDistance(t1.trip, t2.trip)) AS min_dist +FROM QueryLicences l1 +JOIN Vehicles v1 ON v1.licence = l1.licence +JOIN Trips t1 ON t1.vehId = v1.vehId +JOIN QueryLicences l2 ON l1.licenceId < l2.licenceId +JOIN Vehicles v2 ON v2.licence = l2.licence +JOIN Trips t2 ON t2.vehId = v2.vehId +WHERE everEqTh3IndexTh3Index(t1.trip_h3, t2.trip_h3) +GROUP BY l1.licence, l2.licence +ORDER BY l1.licence, l2.licence; diff --git a/berlinmod/q06.sql b/berlinmod/q06.sql new file mode 100644 index 00000000..5352c44c --- /dev/null +++ b/berlinmod/q06.sql @@ -0,0 +1,26 @@ +-- BerlinMOD Q6: Pairs of trucks that ever came within 10 m of each other. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- eDwithin(tgeompoint, tgeompoint, float8) → boolean +-- True if the two trips ever came within the given distance of each other. +-- +-- Spatial prefilter (th3index): trips whose paths never share a cell at any +-- common instant cannot be within 10 m of each other (cell edge at resolution +-- 7 is ≈ 1.2 km, well above the 10 m threshold). +-- +-- MobilityDB operator equivalent: t1.trip |=| t2.trip <= 10.0 + +SELECT v1.licence AS licence1, + v2.licence AS licence2 +FROM Vehicles v1 +JOIN Trips t1 ON t1.vehId = v1.vehId +JOIN Vehicles v2 ON v1.vehId < v2.vehId +JOIN Trips t2 ON t2.vehId = v2.vehId +WHERE v1.type = 'truck' + AND v2.type = 'truck' + AND everEqTh3IndexTh3Index(t1.trip_h3, t2.trip_h3) + AND eDwithin(t1.trip, t2.trip, 10.0) +ORDER BY v1.licence, v2.licence; diff --git a/berlinmod/q07.sql b/berlinmod/q07.sql new file mode 100644 index 00000000..ec702684 --- /dev/null +++ b/berlinmod/q07.sql @@ -0,0 +1,20 @@ +-- BerlinMOD Q7: Trip portions of query-licence vehicles during each query period. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Output convention (binary return): +-- pos is the MEOS hex-WKB encoding of the restricted tgeompoint sequence, +-- produced by asHexWKB(). All three platforms call the same MEOS C function +-- so the output is byte-for-byte identical across platforms. + +SELECT v.vehId AS vehid, + v.licence, + p.periodId AS periodid, + asHexWKB(atTime(t.trip, p.period)) AS pos +FROM QueryLicences l +JOIN Vehicles v ON v.licence = l.licence +JOIN Trips t ON t.vehId = v.vehId +JOIN QueryPeriods p ON true +WHERE atTime(t.trip, p.period) IS NOT NULL +ORDER BY v.vehId, p.periodId, t.tripId; diff --git a/berlinmod/q08.sql b/berlinmod/q08.sql new file mode 100644 index 00000000..da61109b --- /dev/null +++ b/berlinmod/q08.sql @@ -0,0 +1,15 @@ +-- BerlinMOD Q8: Trajectory of each vehicle as a hex-WKB geometry string. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- trajectory() collapses a tgeompoint sequence into its spatial path +-- (LINESTRING for a sequence, POINT for a single instant). Both PostgreSQL +-- COPY and DuckDB COPY serialize the GEOMETRY type as hex WKB in CSV output, +-- and MobilitySpark's trajectory() UDF produces the same format via +-- geo_as_hexewkb(), so the output is byte-for-byte identical across platforms. + +SELECT tripId AS tripid, + trajectory(trip) AS traj +FROM Trips +ORDER BY tripId; diff --git a/berlinmod/q09.sql b/berlinmod/q09.sql new file mode 100644 index 00000000..956b03cf --- /dev/null +++ b/berlinmod/q09.sql @@ -0,0 +1,21 @@ +-- BerlinMOD Q9: What is the longest distance travelled by a vehicle during +-- each of the periods from QueryPeriods? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- atTime(tgeompoint, tstzspan) → tgeompoint (restrict to period) +-- length(tgeompoint) → float8 (Euclidean path length) + +WITH Distances AS ( + SELECT p.periodId, p.period, t.vehId, + SUM(length(atTime(t.trip, p.period))) AS dist + FROM Trips t, QueryPeriods p + WHERE t.trip && p.period + GROUP BY p.periodId, p.period, t.vehId +) +SELECT periodId, period, ROUND(MAX(dist)::numeric, 3) AS maxDist +FROM Distances +GROUP BY periodId, period +ORDER BY periodId; diff --git a/berlinmod/q10.sql b/berlinmod/q10.sql new file mode 100644 index 00000000..a8d9d9b7 --- /dev/null +++ b/berlinmod/q10.sql @@ -0,0 +1,31 @@ +-- BerlinMOD Q10: When did the vehicles with licences from QueryLicences meet +-- other vehicles (within 3 m) and what are the other vehicle IDs? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- expandSpace(tgeompoint, float) → stbox (expand bounding box spatially) +-- tDwithin(tgeompoint, tgeompoint, float) → tbool +-- whenTrue(tbool) → tstzspanset (intervals when predicate holds) +-- +-- Spatial prefilter (th3index): in addition to the existing bbox prefilter +-- t2.trip && expandSpace(t1.trip, 3), we also require the th3index sequences +-- to ever-equal at a common instant. Both prefilters are sound for a 3 m +-- distance threshold (cell edge ≈ 1.2 km, well above 3 m). + +WITH Temp AS ( + SELECT l.licence AS licence1, t2.vehId AS car2Id, + whenTrue(tDwithin(t1.trip, t2.trip, 3.0)) AS periods, + t1.tripId AS tripId1, t2.tripId AS tripId2 + FROM QueryLicences l + JOIN Vehicles v1 ON v1.licence = l.licence + JOIN Trips t1 ON t1.vehId = v1.vehId + JOIN Trips t2 ON t1.vehId <> t2.vehId + WHERE everEqTh3IndexTh3Index(t1.trip_h3, t2.trip_h3) + AND t2.trip && expandSpace(t1.trip, 3) +) +SELECT licence1, car2Id, periods +FROM Temp +WHERE periods IS NOT NULL +ORDER BY licence1, car2Id, tripId1, tripId2; diff --git a/berlinmod/q11.sql b/berlinmod/q11.sql new file mode 100644 index 00000000..7cd204ad --- /dev/null +++ b/berlinmod/q11.sql @@ -0,0 +1,20 @@ +-- BerlinMOD Q11: Which vehicles passed a point from QueryPoints at one of +-- the instants from QueryInstants? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- valueAtTimestamp(tgeompoint, timestamptz) → geometry +-- stbox(geometry, timestamptz) → stbox (index pre-filter constructor) + +WITH Temp AS ( + SELECT p.pointId, p.geom, p.geomWKT, i.instantId, i.instant, t.vehId + FROM Trips t, QueryPoints p, QueryInstants i + WHERE t.trip && stbox(p.geom, i.instant) + AND valueAtTimestamp(t.trip, i.instant) = p.geom +) +SELECT t.pointId, t.geomWKT AS geom, t.instantId, t.instant, v.licence +FROM Temp t +JOIN Vehicles v ON t.vehId = v.vehId +ORDER BY t.pointId, t.instantId, v.licence; diff --git a/berlinmod/q12.sql b/berlinmod/q12.sql new file mode 100644 index 00000000..18ede4d3 --- /dev/null +++ b/berlinmod/q12.sql @@ -0,0 +1,26 @@ +-- BerlinMOD Q12: Which pairs of vehicles were at the same point from +-- QueryPoints at the same instant from QueryInstants? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- valueAtTimestamp(tgeompoint, timestamptz) → geometry +-- stbox(geometry, timestamptz) → stbox (index pre-filter constructor) + +WITH Temp AS ( + SELECT DISTINCT p.pointId, p.geom, p.geomWKT, i.instantId, i.instant, t.vehId + FROM Trips t, QueryPoints p, QueryInstants i + WHERE t.trip && stbox(p.geom, i.instant) + AND valueAtTimestamp(t.trip, i.instant) = p.geom +) +SELECT DISTINCT t1.pointId, t1.geomWKT AS geom, + t1.instantId, t1.instant, + v1.licence AS licence1, v2.licence AS licence2 +FROM Temp t1 +JOIN Vehicles v1 ON t1.vehId = v1.vehId +JOIN Temp t2 ON t1.vehId < t2.vehId + AND t1.pointId = t2.pointId + AND t1.instantId = t2.instantId +JOIN Vehicles v2 ON t2.vehId = v2.vehId +ORDER BY t1.pointId, t1.instantId, licence1, licence2; diff --git a/berlinmod/q13.sql b/berlinmod/q13.sql new file mode 100644 index 00000000..1770debc --- /dev/null +++ b/berlinmod/q13.sql @@ -0,0 +1,26 @@ +-- BerlinMOD Q13: Which vehicles travelled within a region from QueryRegions +-- during a period from QueryPeriods? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Scale note: the original BerlinMOD uses 10-item subsets for each dimension; +-- applying all 100 QueryRegions × 100 QueryPeriods is ~100× more expensive. +-- This query mirrors the original by using only the first 10 regions and 10 periods. +-- +-- Temporal operations used: +-- atTime(tgeompoint, tstzspan) → tgeompoint +-- eIntersects(tgeompoint, geometry) → bool (avoids trajectory() override) +-- stbox(geometry, tstzspan) → stbox (GiST index pre-filter constructor) + +WITH Temp AS ( + SELECT DISTINCT r.regionId, p.periodId, p.period, t.vehId + FROM Trips t, QueryRegions r, QueryPeriods p + WHERE r.regionId <= 10 AND p.periodId <= 10 + AND t.trip && stbox(r.geom, p.period) + AND eIntersects(atTime(t.trip, p.period), r.geom) +) +SELECT DISTINCT t.regionId, t.periodId, t.period, v.licence +FROM Temp t, Vehicles v +WHERE t.vehId = v.vehId +ORDER BY t.regionId, t.periodId, v.licence; diff --git a/berlinmod/q14.sql b/berlinmod/q14.sql new file mode 100644 index 00000000..7788b6bd --- /dev/null +++ b/berlinmod/q14.sql @@ -0,0 +1,20 @@ +-- BerlinMOD Q14: Which vehicles were inside a region from QueryRegions at +-- one of the instants from QueryInstants? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- valueAtTimestamp(tgeompoint, timestamptz) → geometry +-- stbox(geometry, timestamptz) → stbox (index pre-filter constructor) + +WITH Temp AS ( + SELECT DISTINCT r.regionId, i.instantId, i.instant, t.vehId + FROM Trips t, QueryRegions r, QueryInstants i + WHERE t.trip && stbox(r.geom, i.instant) + AND ST_Contains(r.geom, valueAtTimestamp(t.trip, i.instant)) +) +SELECT DISTINCT t.regionId, t.instantId, t.instant, v.licence +FROM Temp t +JOIN Vehicles v ON t.vehId = v.vehId +ORDER BY t.regionId, t.instantId, v.licence; diff --git a/berlinmod/q15.sql b/berlinmod/q15.sql new file mode 100644 index 00000000..db89c3be --- /dev/null +++ b/berlinmod/q15.sql @@ -0,0 +1,26 @@ +-- BerlinMOD Q15: Which vehicles passed a point from QueryPoints during a +-- period from QueryPeriods? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Scale note: the original BerlinMOD uses 10-item subsets for each dimension; +-- applying all 100 QueryPoints × 100 QueryPeriods is ~100× more expensive. +-- This query mirrors the original by using only the first 10 points and 10 periods. +-- +-- Temporal operations used: +-- atTime(tgeompoint, tstzspan) → tgeompoint +-- eIntersects(tgeompoint, geometry) → bool (avoids trajectory() override) +-- stbox(geometry, tstzspan) → stbox (GiST index pre-filter constructor) + +WITH Temp AS ( + SELECT DISTINCT pt.pointId, pt.geom, pt.geomWKT, pr.periodId, pr.period, t.vehId + FROM Trips t, QueryPoints pt, QueryPeriods pr + WHERE pt.pointId <= 10 AND pr.periodId <= 10 + AND t.trip && stbox(pt.geom, pr.period) + AND eIntersects(atTime(t.trip, pr.period), pt.geom) +) +SELECT DISTINCT t.pointId, t.geomWKT AS geom, t.periodId, t.period, v.licence +FROM Temp t, Vehicles v +WHERE t.vehId = v.vehId +ORDER BY t.pointId, t.periodId, v.licence; diff --git a/berlinmod/q16.sql b/berlinmod/q16.sql new file mode 100644 index 00000000..6abf07c7 --- /dev/null +++ b/berlinmod/q16.sql @@ -0,0 +1,37 @@ +-- BerlinMOD Q16: Which pairs of query-licence vehicles were both within a +-- region from QueryRegions during a period from QueryPeriods, but never at +-- the same location at the same time (always disjoint)? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Scale note: the original BerlinMOD uses 10-item subsets for each dimension; +-- applying all 100 QueryLicences × 100 QueryPeriods × 100 QueryRegions is +-- ~10,000× more expensive. This query mirrors the original by using only the +-- first 10 licences, 10 periods, and 10 regions. +-- +-- Temporal operations used: +-- atTime(tgeompoint, tstzspan) → tgeompoint +-- eIntersects(tgeompoint, geometry) → bool (avoids trajectory() override) +-- aDisjoint(tgeompoint, tgeompoint) → bool (always spatially disjoint) +-- stbox(geometry, tstzspan) → stbox (GiST index pre-filter) + +SELECT p.periodId, p.period, r.regionId, + l1.licence AS licence1, l2.licence AS licence2 +FROM QueryLicences l1 +JOIN Vehicles v1 ON v1.licence = l1.licence +JOIN Trips t1 ON t1.vehId = v1.vehId +JOIN QueryLicences l2 ON l1.licenceId < l2.licenceId +JOIN Vehicles v2 ON v2.licence = l2.licence +JOIN Trips t2 ON t2.vehId = v2.vehId +JOIN QueryPeriods p ON true +JOIN QueryRegions r ON true +WHERE l1.licenceId <= 10 AND l2.licenceId <= 10 + AND p.periodId <= 10 + AND r.regionId <= 10 + AND t1.trip && stbox(r.geom, p.period) + AND t2.trip && stbox(r.geom, p.period) + AND eIntersects(atTime(t1.trip, p.period), r.geom) + AND eIntersects(atTime(t2.trip, p.period), r.geom) + AND aDisjoint(atTime(t1.trip, p.period), atTime(t2.trip, p.period)) +ORDER BY p.periodId, r.regionId, l1.licence, l2.licence; diff --git a/berlinmod/q17.sql b/berlinmod/q17.sql new file mode 100644 index 00000000..d1118f47 --- /dev/null +++ b/berlinmod/q17.sql @@ -0,0 +1,19 @@ +-- BerlinMOD Q17: Which point(s) from QueryPoints have been visited by the +-- maximum number of distinct vehicles? +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Temporal operations used: +-- eIntersects(tgeompoint, geometry) → bool (avoids trajectory() override) + +WITH PointCount AS ( + SELECT p.pointId, COUNT(DISTINCT t.vehId) AS hits + FROM Trips t, QueryPoints p + WHERE eIntersects(t.trip, p.geom) + GROUP BY p.pointId +) +SELECT pointId, hits +FROM PointCount +WHERE hits = (SELECT MAX(hits) FROM PointCount) +ORDER BY pointId; diff --git a/berlinmod/qrt.sql b/berlinmod/qrt.sql new file mode 100644 index 00000000..da1622ea --- /dev/null +++ b/berlinmod/qrt.sql @@ -0,0 +1,15 @@ +-- BerlinMOD QRT: Binary roundtrip verification. +-- +-- Portable: works unchanged on MobilityDB/PostgreSQL, MobilityDuck/DuckDB, +-- and MobilitySpark/Spark SQL. +-- +-- Protocol: text in, binary out, byte-equal on reception. +-- Each trip was loaded from WKT text (CSV input). +-- asHexWKB() serializes it to the canonical MEOS hex-WKB (variant 0, +-- little-endian NDR) — the same C function on all three platforms. +-- The hex-WKB strings must be byte-for-byte identical across platforms. + +SELECT tripId AS tripid, + asHexWKB(trip) AS trip_hexwkb +FROM Trips +ORDER BY tripId; diff --git a/berlinmod/run_mbdb.sh b/berlinmod/run_mbdb.sh new file mode 100755 index 00000000..a30dec08 --- /dev/null +++ b/berlinmod/run_mbdb.sh @@ -0,0 +1,116 @@ +#!/usr/bin/env bash +# BerlinMOD portable SQL — MobilityDB/PostgreSQL comparison runner +# +# Loads data, runs Q1/Q2/Q3/Q4/Q5/Q6/Q7/Q8 + QRT, compares all against expected CSV. +# Q3, Q7 and QRT use asHexWKB() for binary return — byte-for-byte identical +# across MobilityDB, MobilityDuck, and MobilitySpark. +# +# Usage (from any directory): +# ./berlinmod/run_mbdb.sh [dbname] # default: berlinmod_portability +# +# Requirements: psql on PATH, MobilityDB installable in the target database. + +set -euo pipefail + +DBNAME="${1:-berlinmod_portability}" +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +DATADIR="${SCRIPT_DIR}/data" +EXPECTED="${SCRIPT_DIR}/expected" +TMP=$(mktemp -d) + +trap 'rm -rf "$TMP"' EXIT + +_psql() { PGOPTIONS='-c search_path=portable,public' psql -d "$DBNAME" "$@"; } + +# Substitute DATADIR placeholder in the loader template +LOADER="${TMP}/load_mbdb.sql" +sed "s|DATADIR|${DATADIR}|g" "${SCRIPT_DIR}/load_mbdb.sql" > "$LOADER" + +echo "=== Loading data into PostgreSQL database: $DBNAME ===" +_psql -f "$LOADER" + +# run_query LABEL SQLFILE [normalize_floats] +# normalize_floats=true: append .0 to bare integers (Q5 only — PostgreSQL +# prints float8 value 3.0 as "3"; other platforms print "3.0"). +run_query() { + local label="$1" + local qfile="$2" + local normalize="${3:-false}" + local rawfile="${TMP}/${label}_raw.csv" + local outfile="${TMP}/${label}.csv" + local sql + sql=$(grep -v '^\s*--' "$qfile" | tr '\n' ' ' | sed 's/;[[:space:]]*$//') + echo "--- Running ${label} ---" + _psql -c "\copy ($sql) TO '${rawfile}' CSV HEADER" + if [ "$normalize" = "true" ]; then + awk 'BEGIN{FS=OFS=","} NR>1{for(i=1;i<=NF;i++) if($i~/^-?[0-9]+$/) $i=$i".0"} 1' \ + "$rawfile" > "$outfile" + else + cp "$rawfile" "$outfile" + fi + echo " $(( $(wc -l < "$outfile") - 1 )) data rows" +} + +compare() { + local label="$1" + local got="${TMP}/${label}.csv" + local exp="${EXPECTED}/${label}.csv" + if diff -u "$exp" "$got" > "${TMP}/diff_${label}.txt" 2>&1; then + echo "[PASS] ${label}" + else + echo "[FAIL] ${label}" + cat "${TMP}/diff_${label}.txt" + FAILURES=$((FAILURES + 1)) + fi +} + +echo "" +echo "=== Running Q1/Q2/Q3/Q4/Q5/Q6/Q7/Q8 + QRT ===" +run_query q01 "${SCRIPT_DIR}/q01.sql" +run_query q02 "${SCRIPT_DIR}/q02.sql" +run_query q03 "${SCRIPT_DIR}/q03.sql" +run_query q04 "${SCRIPT_DIR}/q04.sql" +run_query q05 "${SCRIPT_DIR}/q05.sql" true # float min_dist: PG prints 3, others 3.0 +run_query q06 "${SCRIPT_DIR}/q06.sql" +run_query q07 "${SCRIPT_DIR}/q07.sql" +run_query q08 "${SCRIPT_DIR}/q08.sql" +run_query qrt "${SCRIPT_DIR}/qrt.sql" +run_query q09 "${SCRIPT_DIR}/q09.sql" +run_query q10 "${SCRIPT_DIR}/q10.sql" +run_query q11 "${SCRIPT_DIR}/q11.sql" +run_query q12 "${SCRIPT_DIR}/q12.sql" +run_query q13 "${SCRIPT_DIR}/q13.sql" +run_query q14 "${SCRIPT_DIR}/q14.sql" +run_query q15 "${SCRIPT_DIR}/q15.sql" +run_query q16 "${SCRIPT_DIR}/q16.sql" +run_query q17 "${SCRIPT_DIR}/q17.sql" + +echo "" +echo "=== Comparing against expected output ===" +FAILURES=0 +compare q01 +compare q02 +compare q03 +compare q04 +compare q05 +compare q06 +compare q07 +compare q08 +compare qrt +compare q09 +compare q10 +compare q11 +compare q12 +compare q13 +compare q14 +compare q15 +compare q16 +compare q17 + +echo "" +if [ "$FAILURES" -eq 0 ]; then + echo "ALL PASS — MobilityDB results match expected output." +else + echo "${FAILURES} FAILURE(S) — see diffs above." + exit 1 +fi diff --git a/berlinmod/run_mduck.sh b/berlinmod/run_mduck.sh new file mode 100755 index 00000000..7b3d28ab --- /dev/null +++ b/berlinmod/run_mduck.sh @@ -0,0 +1,122 @@ +#!/usr/bin/env bash +# BerlinMOD portable SQL — MobilityDuck/DuckDB comparison runner +# +# Loads data, runs Q1/Q3/Q4/Q5/Q6 + QRT, compares all against expected CSV. +# Q3 and QRT use asHexWKB() for binary return — byte-for-byte comparable +# across MobilityDB, MobilityDuck, and MobilitySpark. +# +# Usage (from the repository root): +# ./berlinmod/run_mduck.sh [duckdb-binary] +# +# Auto-detects local vs community MobilityDuck build: +# Local build : binary is next to extension/mobilityduck/ directory +# → LOAD mobilityduck; +# Community : extension not found locally +# → INSTALL mobilitydb FROM community; LOAD mobilitydb; + +set -euo pipefail + +DUCKDB="${1:-duckdb}" +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)" +EXPECTED="${SCRIPT_DIR}/expected" +TMP=$(mktemp -d) + +trap 'rm -rf "$TMP"' EXIT + +# Detect local vs community extension +DUCKDB_ABS="$(command -v "$DUCKDB" 2>/dev/null || echo "$DUCKDB")" +DUCKDB_DIR="$(cd "$(dirname "$DUCKDB_ABS")" && pwd 2>/dev/null || true)" +if [ -d "${DUCKDB_DIR}/extension/mobilityduck" ]; then + MOBILITY_LOAD="LOAD mobilityduck;" +else + MOBILITY_LOAD="INSTALL mobilitydb FROM community; LOAD mobilitydb;" +fi + +# Strip trailing semicolon from query to safely embed in COPY (...) +strip_semi() { grep -v '^--' "$1" | tr '\n' ' ' | sed 's/;[[:space:]]*$//'; } + +run_duckdb() { + "$DUCKDB" :memory: "$@" +} + +# run_query LABEL SQLFILE +run_query() { + local label="$1" + local qfile="$2" + local outfile="${TMP}/${label}.csv" + echo "--- Running ${label} ---" + run_duckdb \ + -s "${MOBILITY_LOAD}" \ + -s "$(cat "${SCRIPT_DIR}/load_mduck.sql")" \ + -s "COPY ($(strip_semi "$qfile")) TO '${outfile}' (HEADER, DELIMITER ',')" + echo " $(( $(wc -l < "$outfile") - 1 )) data rows" +} + +compare() { + local label="$1" + local got="${TMP}/${label}.csv" + local exp="${EXPECTED}/${label}.csv" + if diff -u "$exp" "$got" > "${TMP}/diff_${label}.txt" 2>&1; then + echo "[PASS] ${label}" + else + echo "[FAIL] ${label}" + cat "${TMP}/diff_${label}.txt" + FAILURES=$((FAILURES + 1)) + fi +} + +cd "$REPO_ROOT" + +echo "" +echo "=== Running Q01/Q02/Q03/Q04/Q05/Q06/Q07/Q08 + QRT ===" +run_query q01 "${SCRIPT_DIR}/q01.sql" +run_query q02 "${SCRIPT_DIR}/q02.sql" +run_query q03 "${SCRIPT_DIR}/q03.sql" +run_query q04 "${SCRIPT_DIR}/q04.sql" +run_query q05 "${SCRIPT_DIR}/q05.sql" +run_query q06 "${SCRIPT_DIR}/q06.sql" +run_query q07 "${SCRIPT_DIR}/q07.sql" +run_query q08 "${SCRIPT_DIR}/q08.sql" +run_query qrt "${SCRIPT_DIR}/qrt.sql" +echo "" +echo "=== Running Q09/Q10/Q11/Q12/Q13/Q14/Q15/Q16/Q17 ===" +run_query q09 "${SCRIPT_DIR}/q09.sql" +run_query q10 "${SCRIPT_DIR}/q10.sql" +run_query q11 "${SCRIPT_DIR}/q11.sql" +run_query q12 "${SCRIPT_DIR}/q12.sql" +run_query q13 "${SCRIPT_DIR}/q13.sql" +run_query q14 "${SCRIPT_DIR}/q14.sql" +run_query q15 "${SCRIPT_DIR}/q15.sql" +run_query q16 "${SCRIPT_DIR}/q16.sql" +run_query q17 "${SCRIPT_DIR}/q17.sql" + +echo "" +echo "=== Comparing against expected output ===" +FAILURES=0 +compare q01 +compare q02 +compare q03 +compare q04 +compare q05 +compare q06 +compare q07 +compare q08 +compare qrt +compare q09 +compare q10 +compare q11 +compare q12 +compare q13 +compare q14 +compare q15 +compare q16 +compare q17 + +echo "" +if [ "$FAILURES" -eq 0 ]; then + echo "ALL PASS — MobilityDuck results match expected output." +else + echo "${FAILURES} FAILURE(S) — see diffs above." + exit 1 +fi diff --git a/berlinmod/run_mspark.sh b/berlinmod/run_mspark.sh new file mode 100755 index 00000000..b0167fc6 --- /dev/null +++ b/berlinmod/run_mspark.sh @@ -0,0 +1,69 @@ +#!/usr/bin/env bash +# BerlinMOD portable SQL — MobilitySpark/Spark SQL comparison runner +# +# Builds the fat jar (if mvn is available), then submits BerlinMODDemo +# against the shared berlinmod/data/ CSV files and compares all results +# against the expected/ CSV files. +# +# Q3, Q7 and QRT use asHexWKB() for binary return — byte-for-byte identical +# across MobilityDB, MobilityDuck, and MobilitySpark. +# +# Usage (from the repository root): +# ./berlinmod/run_mspark.sh [spark-submit-binary] +# +# Requirements: +# - spark-submit on PATH (or pass explicit path as $1) +# - Java 11/17/21, Maven (mvn) for building +# - target/*-spark.jar must exist or mvn must be available to build it + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)" +SPARK_SUBMIT="${1:-spark-submit}" +DATA_DIR="${SCRIPT_DIR}/data" +EXPECTED_DIR="${SCRIPT_DIR}/expected" +JAR_GLOB="${REPO_ROOT}/target/*-spark.jar" + +cd "$REPO_ROOT" + +# Build fat jar if not present (requires mvn) +JAR=$(ls $JAR_GLOB 2>/dev/null | head -1 || true) +if [ -z "$JAR" ]; then + echo "=== No fat jar found — building with mvn package ===" + if ! command -v mvn >/dev/null 2>&1; then + echo "ERROR: mvn not found. Build the fat jar manually:" + echo " mvn package -DskipTests" + echo " ${SPARK_SUBMIT} --class org.mobilitydb.spark.demo.BerlinMODDemo \\" + echo " target/*-spark.jar ${DATA_DIR} ${EXPECTED_DIR}" + exit 1 + fi + mvn package -DskipTests -q + JAR=$(ls $JAR_GLOB | head -1) +fi +echo "=== Using jar: $JAR ===" + +# Verify spark-submit is available +if ! command -v "$SPARK_SUBMIT" >/dev/null 2>&1; then + echo "ERROR: spark-submit not found. Install Apache Spark and ensure" + echo "spark-submit is on PATH, or pass the path as the first argument." + echo "" + echo "Manual run:" + echo " ${SPARK_SUBMIT} --class org.mobilitydb.spark.demo.BerlinMODDemo \\" + echo " ${JAR} ${DATA_DIR} ${EXPECTED_DIR}" + exit 1 +fi + +LIBMEOS_DIR="${LIBMEOS_DIR:-/usr/local/lib}" + +# Suppress core dumps: a JVM crash produces a 3-5 GB core file that can OOM WSL2. +ulimit -c 0 + +echo "=== Running BerlinMOD Q1/Q2/Q3/Q4/Q5/Q6/Q7/Q8 + QRT on MobilitySpark ===" +"$SPARK_SUBMIT" \ + --class org.mobilitydb.spark.demo.BerlinMODDemo \ + --master "local[2]" \ + --conf "spark.driver.extraJavaOptions=-Djava.library.path=${LIBMEOS_DIR}" \ + "$JAR" \ + "$DATA_DIR" \ + "$EXPECTED_DIR" diff --git a/doc/images/OGC_Associate_Member_3DR.png b/doc/images/OGC_Associate_Member_3DR.png new file mode 100644 index 00000000..4982719b Binary files /dev/null and b/doc/images/OGC_Associate_Member_3DR.png differ diff --git a/doc/images/mobilitydb-logo.png b/doc/images/mobilitydb-logo.png new file mode 100644 index 00000000..83d97dcb Binary files /dev/null and b/doc/images/mobilitydb-logo.png differ diff --git a/doc/images/mobilitydb-logo.svg b/doc/images/mobilitydb-logo.svg new file mode 100644 index 00000000..6c84040e --- /dev/null +++ b/doc/images/mobilitydb-logo.svg @@ -0,0 +1,158 @@ + + + +image/svg+xmlMobilityDB + \ No newline at end of file diff --git a/docs/parity-100.md b/docs/parity-100.md new file mode 100644 index 00000000..c424b6a9 --- /dev/null +++ b/docs/parity-100.md @@ -0,0 +1,95 @@ +# MobilitySpark — portable dialect parity & MobilityDB SQL surface + +Two parity axes, both audited from the repo, both with **all six type +families in scope** — `temporal`, `geo`, `cbuffer`, `npoint`, `pose`, +`rgeo`. No family is deferred or excluded from any headline. + +| Axis | State | Gate | +|---|---|---| +| **Portable bare-name dialect** (RFC #920 — the cross-engine contract) | **29/29 canonical bare names registered, 0 unbacked, all six families — 100%** | [`scripts/portable_parity.py`](../scripts/portable_parity.py) | +| **MobilityDB SQL surface** (every `CREATE FUNCTION`, snake→camel match) | **1353/1462 active addressable covered (92.5%)** — the four sibling families now counted, not excluded | [`scripts/parity-audit.py`](../scripts/parity-audit.py) → [`parity-status.md`](parity-status.md) | + +--- + +## Portable bare-name dialect (this is 100%) + +Single source of truth: `MobilityDB/MEOS-API meta/portable-aliases.json` +(vendored read-only at [`meta/portable-aliases.json`](../meta/portable-aliases.json), +RFC #920, discussion MobilityDB#861, native in MobilityDB#1075). It maps +**29 SQL operator symbols to 29 portable bare function names**, +type-agnostically. + +[`PortableOperatorAliasUDFs`](../src/main/java/org/mobilitydb/spark/portable/PortableOperatorAliasUDFs.java) +registers all 29 bare names as Spark-SQL UDFs, each **reusing the +operator's own existing backing field verbatim** (equivalence by +construction — the alias *is* the operator's backing, it cannot drift). +The backings chosen are the MEOS superclass entrypoints +(`*_temporal_temporal`, `*_tspatial_tspatial`, `t*_temporal_temporal`, +`tdistance_tgeo_tgeo`, `nad_tgeo_*`), which libmeos dispatches internally +for any temporal value carried in the type-erased hex-WKB string — so +`tcbuffer` / `tnpoint` / `tpose` / `trgeometry` are covered by +construction alongside `temporal` and `geo`. The type-qualified +operator spellings they supersede 1:1 (`temporalBefore`, `tnumberLeft`, +`teqTemporal`, …) are dropped — the bare name is the portable contract. + +`python3 scripts/portable_parity.py` gates this: **29/29 backed, 0 +unbacked, 100%** (same prefix logic as MobilityDB/MEOS-API +`portable_parity.py`). + +--- + +## MobilityDB SQL surface (92.5% — remaining work, with a plan) + +The full MobilityDB SQL surface is partitioned by `scripts/parity-audit.py` +into: + +| Bucket | This release | +|--------|---| +| **Active addressable** (any function a Spark UDF can semantically reproduce — **all six families**) | **1353 / 1462 covered (92.5%)** | +| **Out of scope** (PG plumbing: `*_in/_out/_recv/_send`, `_transfn/_combinefn/_finalfn`, GiST/SPGiST opclasses, `_cmp/_eq/.../_hash`, PG range types, PG-extension-only entry points) | excluded by mechanism, not by family | + +PostGIS `BOX2D`/`BOX3D` are *not* out of scope — PostGIS is embedded in +MEOS, so `box2d`/`box3d` UDFs are real. + +**The remaining ~109 (7.5%) is tracked work, not a headline exclusion.** +It is dominated by: + +- the per-overload typed UDF surface of `cbuffer` / `npoint` / `pose` / + `rgeo` (circular buffers, network points, spatial poses, rigid + geometries). These four are **full user-facing temporal types, in + scope** — the portable bare-name dialect above already covers them via + the superclass backings; the gap is the *typed per-family* UDF surface, + to be filled with the same `MeosNative`/`functions.*` reuse pattern, no + new operator logic. +- the previously-noted typed-Datum tile / split / value-set returns + (`getValue`/`getValues`/`*SeqSetGaps`/`timeSplit` double-pointer arrays) + and `segmentMaxDuration`/`asMVTGeom` multi-array outputs. + +Re-run `python3 scripts/parity-audit.py --mdb ../MobilityDB --mspark .` +to regenerate [`parity-status.md`](parity-status.md); `DEFERRED_FAMILIES` +is empty by invariant (cbuffer/npoint/pose/rgeo never deferred). + +--- + +## Why this matters for the ecosystem + +- **One reference, every engine.** A user learns the 29 bare names once; + MobilityDB (native, #1075), MobilityDuck, and MobilitySpark expose the + identical dialect. The BerlinMOD Q1–Q17 portable SQL runs unchanged + across all three. +- **Equivalence by construction.** Every alias reuses the operator's own + backing C symbol — no reimplementation, no second code path, no drift. +- **Reusable audit.** `scripts/parity-audit.py` (surface) and + `scripts/portable_parity.py` (dialect) regenerate from the repo and run + in CI; both keep all six families in scope. + +--- + +## How to verify + +```bash +mvn test # full unit suite (CI: Linux green) +python3 scripts/portable_parity.py # 29/29, 0 unbacked (exit 0) +python3 scripts/parity-audit.py \ + --mdb ../MobilityDB --mspark . # regenerates docs/parity-status.md +``` diff --git a/docs/parity-status.md b/docs/parity-status.md new file mode 100644 index 00000000..1c43011a --- /dev/null +++ b/docs/parity-status.md @@ -0,0 +1,338 @@ +# MobilitySpark parity status — surface-level audit + +Generated 2026-05-18. **Active addressable scope** (temporal + geo, excluding PG-only helpers): 1353/1462 names covered (92.5%). + +**Out of scope** (PG-only — no Spark equivalent exists): 594 names skipped — 84 from PG-only sections (GiST/SPGiST opclasses, set/span/spanset index files, `019_geo_constructors.in.sql` PG geometric types, `999_oid_cache.in.sql`) plus 510 PG helper functions inside active sections (`*_in/_out/_recv/_send`, `*_transfn/_combinefn/_finalfn/_serialize/_deserialize`, `*_sel/_joinsel/_supportfn/_analyze`, `*_typmod_in/_typmod_out`). Listed in appendix B; not counted in the headline. + +**All six type families in scope** (temporal, geo, cbuffer, npoint, pose, rgeo). None is deferred or excluded from the headline — they are full user-facing temporal types covered like every other family (RFC #920; MobilityDB#1075). + +**Methodology**: parsed `CREATE FUNCTION` from `mobilitydb/sql/**/*.in.sql` and `spark.udf().register("name", ...)` (scalar + UDAF) from `MobilitySpark/src/main/java/**/*.java`. Match is by **function name only**, case-insensitive; MobilityDB snake_case is converted to camelCase before comparison so e.g. `tdistance_tgeo_geo` matches `tdistanceTgeoGeo`. A name registered in MobilitySpark is treated as covering all its overloads; per-overload signature parity is not verified at this granularity. + +**Caveats**: +- A name match doesn't prove signature parity. e.g. `before(temporal, temporal)` registered in MobilitySpark does not necessarily cover MobilityDB's `before(tstzspan, temporal)`. +- Spark SQL has no infix-operator extension API; equivalent named functions are registered. The `MDB operators` column lists how many `CREATE OPERATOR` statements exist in the section, all of which collapse to named-function form in MobilitySpark. + +Regenerate with `python3 scripts/parity-audit.py --mdb ../MobilityDB --mspark . --out docs/parity-status.md`. The OUT_OF_SCOPE_SECTIONS / OUT_OF_SCOPE_NAME_SUFFIXES / DEFERRED_FAMILIES sets at the top of that script control bucketing. + +## Active-scope coverage summary (addressable surface) + +| Section | Addressable | Covered | Missing | Coverage | OOS | MDB operators | +|---|---:|---:|---:|---:|---:|---:| +| `cbuffer/150_cbuffer.in.sql` | 18 | 8 | 10 | 44% | 13 | 7 | +| `cbuffer/151_cbufferset.in.sql` | 27 | 25 | 2 | 93% | 15 | 23 | +| `cbuffer/152_tcbuffer.in.sql` | 71 | 59 | 12 | 83% | 13 | 6 | +| `cbuffer/154_tcbuffer_compops.in.sql` | 2 | 2 | 0 | 100% | 4 | 18 | +| `cbuffer/155_tcbuffer_spatialfuncs.in.sql` | 11 | 11 | 0 | 100% | 0 | 0 | +| `cbuffer/158_tcbuffer_topops.in.sql` | 7 | 7 | 0 | 100% | 0 | 25 | +| `cbuffer/159_tcbuffer_posops.in.sql` | 12 | 12 | 0 | 100% | 0 | 44 | +| `cbuffer/160_tcbuffer_distance.in.sql` | 5 | 5 | 0 | 100% | 0 | 17 | +| `cbuffer/161_tcbuffer_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 7 | 0 | +| `cbuffer/162_tcbuffer_spatialrels.in.sql` | 13 | 13 | 0 | 100% | 0 | 0 | +| `cbuffer/164_tcbuffer_tempspatialrels.in.sql` | 6 | 6 | 0 | 100% | 0 | 0 | +| `cbuffer/166_tcbuffer_indexes.in.sql` | 1 | 0 | 1 | 0% | 0 | 0 | +| `geo/050_geoset.in.sql` | 34 | 34 | 0 | 100% | 22 | 46 | +| `geo/051_stbox.in.sql` | 66 | 66 | 0 | 100% | 17 | 29 | +| `geo/052_tgeo.in.sql` | 62 | 62 | 0 | 100% | 18 | 12 | +| `geo/052_tpoint.in.sql` | 62 | 62 | 0 | 100% | 16 | 12 | +| `geo/053_tgeo_inout.in.sql` | 18 | 18 | 0 | 100% | 0 | 0 | +| `geo/053_tpoint_inout.in.sql` | 18 | 18 | 0 | 100% | 0 | 0 | +| `geo/054_tgeo_compops.in.sql` | 2 | 2 | 0 | 100% | 5 | 36 | +| `geo/054_tpoint_compops.in.sql` | 2 | 2 | 0 | 100% | 4 | 36 | +| `geo/056_tgeo_spatialfuncs.in.sql` | 17 | 17 | 0 | 100% | 0 | 0 | +| `geo/056_tpoint_spatialfuncs.in.sql` | 29 | 29 | 0 | 100% | 1 | 0 | +| `geo/058_tgeo_tile.in.sql` | 5 | 5 | 0 | 100% | 0 | 0 | +| `geo/058_tpoint_tile.in.sql` | 11 | 11 | 0 | 100% | 0 | 0 | +| `geo/060_tgeo_boxops.in.sql` | 13 | 13 | 0 | 100% | 0 | 50 | +| `geo/060_tpoint_boxops.in.sql` | 13 | 13 | 0 | 100% | 0 | 50 | +| `geo/062_tgeo_posops.in.sql` | 16 | 16 | 0 | 100% | 0 | 76 | +| `geo/062_tpoint_posops.in.sql` | 16 | 16 | 0 | 100% | 0 | 76 | +| `geo/064_tgeo_distance.in.sql` | 4 | 4 | 0 | 100% | 0 | 16 | +| `geo/064_tpoint_distance.in.sql` | 4 | 4 | 0 | 100% | 0 | 21 | +| `geo/066_tpoint_similarity.in.sql` | 5 | 5 | 0 | 100% | 0 | 0 | +| `geo/068_tgeo_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 9 | 0 | +| `geo/068_tpoint_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 12 | 0 | +| `geo/070_tgeo_spatialrels.in.sql` | 14 | 14 | 0 | 100% | 0 | 0 | +| `geo/070_tpoint_spatialrels.in.sql` | 12 | 12 | 0 | 100% | 0 | 0 | +| `geo/072_tgeo_tempspatialrels.in.sql` | 6 | 6 | 0 | 100% | 0 | 0 | +| `geo/072_tpoint_tempspatialrels.in.sql` | 5 | 5 | 0 | 100% | 0 | 0 | +| `geo/076_tgeo_analytics.in.sql` | 13 | 13 | 0 | 100% | 0 | 0 | +| `geo/076_tpoint_analytics.in.sql` | 18 | 18 | 0 | 100% | 0 | 0 | +| `geo/078_tpoint_datagen.in.sql` | 0 | 0 | 0 | 0% | 1 | 0 | +| `npoint/081_npoint.in.sql` | 19 | 8 | 11 | 42% | 22 | 12 | +| `npoint/082_npointset.in.sql` | 28 | 22 | 6 | 79% | 15 | 23 | +| `npoint/083_tnpoint.in.sql` | 65 | 55 | 10 | 85% | 12 | 6 | +| `npoint/085_tnpoint_compops.in.sql` | 2 | 2 | 0 | 100% | 4 | 18 | +| `npoint/087_tnpoint_spatialfuncs.in.sql` | 12 | 12 | 0 | 100% | 0 | 0 | +| `npoint/089_tnpoint_topops.in.sql` | 7 | 7 | 0 | 100% | 0 | 25 | +| `npoint/090_tnpoint_posops.in.sql` | 12 | 12 | 0 | 100% | 0 | 44 | +| `npoint/091_tnpoint_routeops.in.sql` | 4 | 0 | 4 | 0% | 0 | 20 | +| `npoint/092_tnpoint_gin.in.sql` | 3 | 0 | 3 | 0% | 0 | 0 | +| `npoint/093_tnpoint_distance.in.sql` | 4 | 4 | 0 | 100% | 0 | 12 | +| `npoint/095_tnpoint_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 8 | 0 | +| `npoint/098_tnpoint_indexes.in.sql` | 1 | 0 | 1 | 0% | 0 | 0 | +| `pose/100_pose.in.sql` | 21 | 11 | 10 | 52% | 13 | 7 | +| `pose/101_poseset.in.sql` | 31 | 26 | 5 | 84% | 15 | 23 | +| `pose/102_tpose.in.sql` | 72 | 58 | 14 | 81% | 13 | 6 | +| `pose/104_tpose_compops.in.sql` | 2 | 2 | 0 | 100% | 4 | 18 | +| `pose/105_tpose_spatialfuncs.in.sql` | 8 | 8 | 0 | 100% | 0 | 0 | +| `pose/108_tpose_topops.in.sql` | 7 | 7 | 0 | 100% | 0 | 25 | +| `pose/109_tpose_posops.in.sql` | 16 | 16 | 0 | 100% | 0 | 56 | +| `pose/111_tpose_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 7 | 0 | +| `pose/113_tpose_distance.in.sql` | 4 | 4 | 0 | 100% | 0 | 12 | +| `pose/114_tpose_indexes.in.sql` | 1 | 0 | 1 | 0% | 0 | 0 | +| `rgeo/122_trgeo.in.sql` | 74 | 62 | 12 | 84% | 13 | 6 | +| `rgeo/124_trgeo_compops.in.sql` | 2 | 2 | 0 | 100% | 4 | 18 | +| `rgeo/125_trgeo_spatialfuncs.in.sql` | 8 | 8 | 0 | 100% | 0 | 0 | +| `rgeo/128_trgeo_topops.in.sql` | 5 | 5 | 0 | 100% | 0 | 25 | +| `rgeo/129_trgeo_posops.in.sql` | 12 | 12 | 0 | 100% | 0 | 44 | +| `rgeo/131_trgeo_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 7 | 0 | +| `rgeo/133_trgeo_distance.in.sql` | 4 | 4 | 0 | 100% | 0 | 12 | +| `rgeo/133_trgeo_vclip.in.sql` | 6 | 0 | 6 | 0% | 0 | 0 | +| `rgeo/134_trgeo_indexes.in.sql` | 1 | 0 | 1 | 0% | 0 | 0 | +| `temporal/001_set.in.sql` | 39 | 39 | 0 | 100% | 43 | 38 | +| `temporal/002_set_ops.in.sql` | 11 | 11 | 0 | 100% | 0 | 176 | +| `temporal/003_span.in.sql` | 36 | 36 | 0 | 100% | 32 | 30 | +| `temporal/005_span_ops.in.sql` | 12 | 12 | 0 | 100% | 0 | 160 | +| `temporal/007_spanset.in.sql` | 51 | 51 | 0 | 100% | 30 | 30 | +| `temporal/009_spanset_ops.in.sql` | 14 | 14 | 0 | 100% | 0 | 280 | +| `temporal/015_span_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 10 | 0 | +| `temporal/021_tbox.in.sql` | 43 | 43 | 0 | 100% | 17 | 21 | +| `temporal/022_temporal.in.sql` | 94 | 94 | 0 | 100% | 23 | 24 | +| `temporal/023_temporal_inout.in.sql` | 16 | 16 | 0 | 100% | 0 | 0 | +| `temporal/025_temporal_tile.in.sql` | 16 | 16 | 0 | 100% | 0 | 0 | +| `temporal/026_tnumber_mathfuncs.in.sql` | 17 | 17 | 0 | 100% | 0 | 24 | +| `temporal/028_tbool_boolops.in.sql` | 4 | 4 | 0 | 100% | 0 | 7 | +| `temporal/029_ttext_textfuncs.in.sql` | 4 | 4 | 0 | 100% | 0 | 3 | +| `temporal/030_temporal_compops.in.sql` | 6 | 6 | 0 | 100% | 13 | 180 | +| `temporal/032_temporal_boxops.in.sql` | 11 | 11 | 0 | 100% | 0 | 100 | +| `temporal/034_temporal_posops.in.sql` | 8 | 8 | 0 | 100% | 0 | 112 | +| `temporal/036_tnumber_distance.in.sql` | 2 | 2 | 0 | 100% | 0 | 17 | +| `temporal/038_temporal_similarity.in.sql` | 5 | 5 | 0 | 100% | 0 | 0 | +| `temporal/040_temporal_aggfuncs.in.sql` | 0 | 0 | 0 | 0% | 40 | 0 | +| `temporal/042_temporal_waggfuncs.in.sql` | 0 | 0 | 0 | 0% | 8 | 0 | +| `temporal/046_temporal_analytics.in.sql` | 4 | 4 | 0 | 100% | 0 | 0 | +| **TOTAL (active)** | **1462** | **1353** | **109** | **93%** | **510** | — | + +## Missing function names per active section + +### `cbuffer/150_cbuffer.in.sql` — 10 missing of 18 addressable (44% covered) + +- `cbuffer` → `cbuffer` (2 overloads) +- `cbuffer_contains` → `cbufferContains` +- `cbuffer_covers` → `cbufferCovers` +- `cbuffer_disjoint` → `cbufferDisjoint` +- `cbuffer_dwithin` → `cbufferDwithin` +- `cbuffer_intersects` → `cbufferIntersects` +- `cbuffer_same` → `cbufferSame` +- `cbuffer_touches` → `cbufferTouches` +- `point` → `point` +- `radius` → `radius` + +### `cbuffer/151_cbufferset.in.sql` — 2 missing of 27 addressable (93% covered) + +- `cbuffersetFromBinary` → `cbuffersetFromBinary` +- `cbuffersetFromHexWKB` → `cbuffersetFromHexWKB` + +### `cbuffer/152_tcbuffer.in.sql` — 12 missing of 71 addressable (83% covered) + +- `points` → `points` +- `radius` → `radius` +- `tcbuffer` → `tcbuffer` (8 overloads) +- `tcbufferFromBinary` → `tcbufferFromBinary` +- `tcbufferFromEWKB` → `tcbufferFromEWKB` +- `tcbufferFromEWKT` → `tcbufferFromEWKT` +- `tcbufferFromHexEWKB` → `tcbufferFromHexEWKB` +- `tcbufferFromText` → `tcbufferFromText` +- `tcbufferInst` → `tcbufferInst` +- `tcbufferSeq` → `tcbufferSeq` (2 overloads) +- `tcbufferSeqSet` → `tcbufferSeqSet` (2 overloads) +- `tcbufferSeqSetGaps` → `tcbufferSeqSetGaps` + +### `cbuffer/166_tcbuffer_indexes.in.sql` — 1 missing of 1 addressable (0% covered) + +- `tcbuffer_gist_consistent` → `tcbufferGistConsistent` + +### `npoint/081_npoint.in.sql` — 11 missing of 19 addressable (42% covered) + +- `endPosition` → `endPosition` +- `getPosition` → `getPosition` +- `npoint` → `npoint` (2 overloads) +- `npointFromBinary` → `npointFromBinary` +- `npointFromEWKB` → `npointFromEWKB` +- `npointFromEWKT` → `npointFromEWKT` +- `npointFromHexEWKB` → `npointFromHexEWKB` +- `npointFromText` → `npointFromText` +- `nsegment` → `nsegment` (3 overloads) +- `route` → `route` (2 overloads) +- `startPosition` → `startPosition` + +### `npoint/082_npointset.in.sql` — 6 missing of 28 addressable (79% covered) + +- `npointsetFromBinary` → `npointsetFromBinary` +- `npointsetFromEWKB` → `npointsetFromEWKB` +- `npointsetFromEWKT` → `npointsetFromEWKT` +- `npointsetFromHexWKB` → `npointsetFromHexWKB` +- `npointsetFromText` → `npointsetFromText` +- `routes` → `routes` + +### `npoint/083_tnpoint.in.sql` — 10 missing of 65 addressable (85% covered) + +- `positions` → `positions` +- `route` → `route` +- `routes` → `routes` +- `tnpoint` → `tnpoint` (6 overloads) +- `tnpointFromBinary` → `tnpointFromBinary` +- `tnpointFromHexWKB` → `tnpointFromHexWKB` +- `tnpointInst` → `tnpointInst` +- `tnpointSeq` → `tnpointSeq` (3 overloads) +- `tnpointSeqSet` → `tnpointSeqSet` (3 overloads) +- `tnpointSeqSetGaps` → `tnpointSeqSetGaps` + +### `npoint/091_tnpoint_routeops.in.sql` — 4 missing of 4 addressable (0% covered) + +- `contained_rid` → `containedRid` (5 overloads) +- `contains_rid` → `containsRid` (5 overloads) +- `overlaps_rid` → `overlapsRid` (3 overloads) +- `same_rid` → `sameRid` (7 overloads) + +### `npoint/092_tnpoint_gin.in.sql` — 3 missing of 3 addressable (0% covered) + +- `tnpoint_gin_extract_query` → `tnpointGinExtractQuery` +- `tnpoint_gin_extract_value` → `tnpointGinExtractValue` +- `tnpoint_gin_triconsistent` → `tnpointGinTriconsistent` + +### `npoint/098_tnpoint_indexes.in.sql` — 1 missing of 1 addressable (0% covered) + +- `tnpoint_gist_consistent` → `tnpointGistConsistent` + +### `pose/100_pose.in.sql` — 10 missing of 21 addressable (52% covered) + +- `orientation` → `orientation` +- `point` → `point` +- `pose` → `pose` (4 overloads) +- `poseFromBinary` → `poseFromBinary` +- `poseFromEWKB` → `poseFromEWKB` +- `poseFromEWKT` → `poseFromEWKT` +- `poseFromHexEWKB` → `poseFromHexEWKB` +- `poseFromText` → `poseFromText` +- `pose_same` → `poseSame` +- `rotation` → `rotation` + +### `pose/101_poseset.in.sql` — 5 missing of 31 addressable (84% covered) + +- `posesetFromBinary` → `posesetFromBinary` +- `posesetFromEWKB` → `posesetFromEWKB` +- `posesetFromEWKT` → `posesetFromEWKT` +- `posesetFromHexWKB` → `posesetFromHexWKB` +- `posesetFromText` → `posesetFromText` + +### `pose/102_tpose.in.sql` — 14 missing of 72 addressable (81% covered) + +- `orientation` → `orientation` +- `points` → `points` +- `rotation` → `rotation` +- `tpose` → `tpose` (5 overloads) +- `tposeFromBinary` → `tposeFromBinary` +- `tposeFromEWKB` → `tposeFromEWKB` +- `tposeFromEWKT` → `tposeFromEWKT` +- `tposeFromHexEWKB` → `tposeFromHexEWKB` +- `tposeFromMFJSON` → `tposeFromMFJSON` +- `tposeFromText` → `tposeFromText` +- `tposeInst` → `tposeInst` +- `tposeSeq` → `tposeSeq` (2 overloads) +- `tposeSeqSet` → `tposeSeqSet` (2 overloads) +- `tposeSeqSetGaps` → `tposeSeqSetGaps` + +### `pose/114_tpose_indexes.in.sql` — 1 missing of 1 addressable (0% covered) + +- `tpose_gist_consistent` → `tposeGistConsistent` + +### `rgeo/122_trgeo.in.sql` — 12 missing of 74 addressable (84% covered) + +- `tpose` → `tpose` +- `trgeometry` → `trgeometry` (3 overloads) +- `trgeometryFromBinary` → `trgeometryFromBinary` +- `trgeometryFromEWKB` → `trgeometryFromEWKB` +- `trgeometryFromEWKT` → `trgeometryFromEWKT` +- `trgeometryFromHexEWKB` → `trgeometryFromHexEWKB` +- `trgeometryFromMFJSON` → `trgeometryFromMFJSON` +- `trgeometryFromText` → `trgeometryFromText` +- `trgeometryInst` → `trgeometryInst` +- `trgeometrySeq` → `trgeometrySeq` (2 overloads) +- `trgeometrySeqSet` → `trgeometrySeqSet` (2 overloads) +- `trgeometrySeqSetGaps` → `trgeometrySeqSetGaps` + +### `rgeo/133_trgeo_vclip.in.sql` — 6 missing of 6 addressable (0% covered) + +- `v_clip_poly_point` → `vClipPolyPoint` +- `v_clip_poly_poly` → `vClipPolyPoly` +- `v_clip_tpoly_point` → `vClipTpolyPoint` +- `v_clip_tpoly_poly` → `vClipTpolyPoly` +- `v_clip_tpoly_tpoint` → `vClipTpolyTpoint` +- `v_clip_tpoly_tpoly` → `vClipTpolyTpoly` + +### `rgeo/134_trgeo_indexes.in.sql` — 1 missing of 1 addressable (0% covered) + +- `trgeometry_gist_consistent` → `trgeometryGistConsistent` + +## Appendix B — Out of scope (PG-only, no Spark equivalent) + +These entries are PG-specific helpers — index opclasses, aggregate transition/combine/final/serialize callbacks, planner hooks (`_sel`, `_joinsel`, `_supportfn`, `_analyze`), text/binary I/O helpers (`_in`, `_out`, `_recv`, `_send`), type modifier helpers, the `999_oid_cache` PG catalog hook, and PG geometric type constructors (`019_geo_constructors`). None of them have Spark equivalents and they should not be implemented; listed here only for completeness. + +### Whole sections excluded + +| Section | Names | +|---|---:| +| `geo/073_tgeo_gist.in.sql` | 8 | +| `geo/073_tpoint_gist.in.sql` | 3 | +| `geo/074_tgeo_spgist.in.sql` | 9 | +| `temporal/011_span_indexes.in.sql` | 19 | +| `temporal/012_spanset_indexes.in.sql` | 3 | +| `temporal/013_set_indexes.in.sql` | 10 | +| `temporal/019_geo_constructors.in.sql` | 7 | +| `temporal/043_temporal_gist.in.sql` | 14 | +| `temporal/044_temporal_spgist.in.sql` | 10 | +| `temporal/999_oid_cache.in.sql` | 1 | + +### PG helpers inside active sections + +| Section | PG helpers | +|---|---:| +| `cbuffer/150_cbuffer.in.sql` | 13 | +| `cbuffer/151_cbufferset.in.sql` | 15 | +| `cbuffer/152_tcbuffer.in.sql` | 13 | +| `cbuffer/154_tcbuffer_compops.in.sql` | 4 | +| `cbuffer/161_tcbuffer_aggfuncs.in.sql` | 7 | +| `geo/050_geoset.in.sql` | 22 | +| `geo/051_stbox.in.sql` | 17 | +| `geo/052_tgeo.in.sql` | 18 | +| `geo/052_tpoint.in.sql` | 16 | +| `geo/054_tgeo_compops.in.sql` | 5 | +| `geo/054_tpoint_compops.in.sql` | 4 | +| `geo/056_tpoint_spatialfuncs.in.sql` | 1 | +| `geo/068_tgeo_aggfuncs.in.sql` | 9 | +| `geo/068_tpoint_aggfuncs.in.sql` | 12 | +| `geo/078_tpoint_datagen.in.sql` | 1 | +| `npoint/081_npoint.in.sql` | 22 | +| `npoint/082_npointset.in.sql` | 15 | +| `npoint/083_tnpoint.in.sql` | 12 | +| `npoint/085_tnpoint_compops.in.sql` | 4 | +| `npoint/095_tnpoint_aggfuncs.in.sql` | 8 | +| `pose/100_pose.in.sql` | 13 | +| `pose/101_poseset.in.sql` | 15 | +| `pose/102_tpose.in.sql` | 13 | +| `pose/104_tpose_compops.in.sql` | 4 | +| `pose/111_tpose_aggfuncs.in.sql` | 7 | +| `rgeo/122_trgeo.in.sql` | 13 | +| `rgeo/124_trgeo_compops.in.sql` | 4 | +| `rgeo/131_trgeo_aggfuncs.in.sql` | 7 | +| `temporal/001_set.in.sql` | 43 | +| `temporal/003_span.in.sql` | 32 | +| `temporal/007_spanset.in.sql` | 30 | +| `temporal/015_span_aggfuncs.in.sql` | 10 | +| `temporal/021_tbox.in.sql` | 17 | +| `temporal/022_temporal.in.sql` | 23 | +| `temporal/030_temporal_compops.in.sql` | 13 | +| `temporal/040_temporal_aggfuncs.in.sql` | 40 | +| `temporal/042_temporal_waggfuncs.in.sql` | 8 | + diff --git a/lib/libmeos.so b/lib/libmeos.so new file mode 100644 index 00000000..afb621ea Binary files /dev/null and b/lib/libmeos.so differ diff --git a/libs/JMEOS-1.4.jar b/libs/JMEOS-1.4.jar new file mode 100644 index 00000000..a9af64bf Binary files /dev/null and b/libs/JMEOS-1.4.jar differ diff --git a/libs/MobilityDB-JMEOS-Linux.jar b/libs/MobilityDB-JMEOS-Linux.jar deleted file mode 100644 index b19aa037..00000000 Binary files a/libs/MobilityDB-JMEOS-Linux.jar and /dev/null differ diff --git a/libs/MobilityDB-JMEOS.jar b/libs/MobilityDB-JMEOS.jar deleted file mode 100644 index a2488c2c..00000000 Binary files a/libs/MobilityDB-JMEOS.jar and /dev/null differ diff --git a/meta/portable-aliases.json b/meta/portable-aliases.json new file mode 100644 index 00000000..1cabac15 --- /dev/null +++ b/meta/portable-aliases.json @@ -0,0 +1,60 @@ +{ + "_comment": "Canonical portable bare-name dialect — the single codegen source of truth (RFC #920). Every binding/engine generates the SAME bare names from this mapping so users learn one reference and assume the rest. Operators are SQL operator symbols; bareName is the portable function name. The mapping is type-agnostic: it applies to EVERY temporal type family.", + "provenance": { + "discussion": "MobilityDB#861", + "rfc": "MobilityDB RFC #920 (doc/rfc/sql-portability/README.md, branch rfc/sql-portability)", + "nativePR": "MobilityDB#1075 (1303 operator-overload aliases, each reusing the operator's own C symbol — identical by construction; CI-gated by tools/portable_aliases/generate.py --check)", + "manualChapter": "MobilityDB#1078" + }, + "families": { + "topology": [{"operator": "&&", "bareName": "overlaps"}, + {"operator": "@>", "bareName": "contains"}, + {"operator": "<@", "bareName": "contained"}, + {"operator": "-|-", "bareName": "adjacent"}], + "timePosition": [{"operator": "<<#", "bareName": "before"}, + {"operator": "#>>", "bareName": "after"}, + {"operator": "&<#", "bareName": "overbefore"}, + {"operator": "#&>", "bareName": "overafter"}], + "spaceX": [{"operator": "<<", "bareName": "left"}, + {"operator": ">>", "bareName": "right"}, + {"operator": "&<", "bareName": "overleft"}, + {"operator": "&>", "bareName": "overright"}], + "spaceY": [{"operator": "<<|", "bareName": "below"}, + {"operator": "|>>", "bareName": "above"}, + {"operator": "&<|", "bareName": "overbelow"}, + {"operator": "|&>", "bareName": "overabove"}], + "spaceZ": [{"operator": "<>", "bareName": "back"}, + {"operator": "&", "bareName": "overback"}], + "temporalComparison": [{"operator": "#=", "bareName": "teq"}, + {"operator": "#<>", "bareName": "tne"}, + {"operator": "#<", "bareName": "tlt"}, + {"operator": "#<=", "bareName": "tle"}, + {"operator": "#>", "bareName": "tgt"}, + {"operator": "#>=", "bareName": "tge"}], + "distance": [{"operator": "<->", "bareName": "tdistance"}, + {"operator": "|=|", "bareName": "nearestApproachDistance"}], + "same": [{"operator": "~=", "bareName": "same"}] + }, + "alreadyCanonical": [ + {"family": "ever", "operators": ["?="], "pattern": "ever_*"}, + {"family": "always", "operators": ["%="], "pattern": "always_*"}, + {"functions": ["eIntersects", "atTime", "restriction functions", + "spatial-relationship functions"]} + ], + "_explicitBackingComment": "Bare names whose MEOS C family prefix differs from the bare name itself. Verified against the catalog (not guessed): `nearestApproachDistance` is backed by the `nad_*` family (35 functions). Lets the parity audit resolve 100% honestly instead of false-flagging a real, present family.", + "explicitBacking": { + "nearestApproachDistance": ["nad"] + }, + "scope": { + "inScopeTypeFamilies": ["temporal", "geo", "cbuffer", "npoint", "pose", + "rgeo"], + "note": "cbuffer / npoint / pose / rgeo are FULL user-facing temporal types and ARE in scope — covered like every other type. PR #1075 already aliases all six families (1303 aliases). They must NOT be excluded from any parity headline; an upstream/audit note that 'defers' or 'jointly excludes' them is a known error being corrected — where another engine defers them, that is incomplete work to close (a gap with a plan), never an accepted exclusion." + }, + "notes": [ + "Generate aliases by reusing each operator's own backing C function (equivalence by construction), never by reimplementing; mirror MobilityDB tools/portable_aliases/generate.py + its 100%-coverage audit.", + "User-facing API uses the full name `trgeometry`; internal functions keep the `trgeo_` prefix — do NOT normalize the internal prefix.", + "Goal: 100% parity ecosystem-wide — every operator has its bare name on every engine, no gaps, no headline exclusions." + ] +} diff --git a/pom.xml b/pom.xml index 417d4287..6be2aeb4 100644 --- a/pom.xml +++ b/pom.xml @@ -4,38 +4,106 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 - org.mobiltydb - SparkMeos - 1.0-SNAPSHOT + org.mobilitydb + mobilityspark + 0.1.0-SNAPSHOT - 17 - 17 + 21 + 21 UTF-8 + 3.5.1 + 2.13 + ${project.basedir}/libs/JMEOS-1.4.jar + org.apache.spark - spark-core_2.13 - 3.4.0 + spark-core_${scala.binary.version} + ${spark.version} + provided org.apache.spark - spark-sql_2.13 - 3.4.0 - compile + spark-sql_${scala.binary.version} + ${spark.version} + provided + org.jmeos - meos - 1.0 + jmeos + 1.4 + + com.github.jnr jnr-ffi - 2.2.11 + 2.2.17 + + + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test - \ No newline at end of file + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.5.1 + + + package + shade + + true + spark + + + *:* + + META-INF/*.SF + META-INF/*.DSA + META-INF/*.RSA + + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.1.2 + + false + + 1 + false + + -Djava.library.path=${project.basedir}/lib:/usr/local/lib + + + + + diff --git a/scripts/parity-audit.py b/scripts/parity-audit.py new file mode 100644 index 00000000..c7227752 --- /dev/null +++ b/scripts/parity-audit.py @@ -0,0 +1,529 @@ +#!/usr/bin/env python3 +"""Compare MobilityDB SQL surface against MobilitySpark registered surface. + +Adapted from MobilityDuck/scripts/parity-audit.py. Same OUT_OF_SCOPE / +DEFERRED bucketing model; differences: + +- MobilitySpark Java sources (`*.java`) instead of C++; matches Spark UDF + registration: `spark.udf().register("name", ...)` and the UDAF variant + `spark.udf().register("name", org.apache.spark.sql.functions.udaf(...)`. +- MobilityDB SQL is snake_case; MobilitySpark UDFs are camelCase. Match + converts snake_case → camelCase before comparison. + +Usage: + python3 scripts/parity-audit.py \\ + --mdb /path/to/MobilityDB \\ + --mspark /path/to/MobilitySpark \\ + --out docs/parity-status.md +""" + +import argparse +import collections +import glob +import os +import re +import sys +from datetime import date + + +# Type families deferred from the active parity sweep. +# +# EMPTY BY INVARIANT. cbuffer / npoint / pose / rgeo are FULL user-facing +# temporal types and ARE in scope — covered like every other family (RFC +# #920; MobilityDB#1075 aliases all six). They must never be excluded from +# the parity headline. Re-deferring any of them is incomplete work, not an +# accepted end state. Keep this set empty. +DEFERRED_FAMILIES = set() + + +# Whole SQL sections that are PG-only (no Spark equivalent exists). +# Match by tail of the relpath under mobilitydb/sql/. +OUT_OF_SCOPE_SECTIONS = { + "temporal/011_span_indexes.in.sql", # GiST/SPGiST opclasses + "temporal/012_spanset_indexes.in.sql", # GiST/SPGiST opclasses + "temporal/013_set_indexes.in.sql", # GiST/SPGiST opclasses + "temporal/019_geo_constructors.in.sql", # PG geometric types + "temporal/043_temporal_gist.in.sql", # GiST support + "temporal/044_temporal_spgist.in.sql", # SPGiST support + "temporal/999_oid_cache.in.sql", # PG catalog hook + "geo/073_tgeo_gist.in.sql", # GiST support + "geo/073_tpoint_gist.in.sql", # GiST support + "geo/074_tgeo_spgist.in.sql", # SPGiST support + "geo/074_tpoint_spgist.in.sql", # SPGiST support +} + + +# Function-name suffixes that mark PG-only helpers. +OUT_OF_SCOPE_NAME_SUFFIXES = ( + "_transfn", + "_combinefn", + "_finalfn", + "_serialize", + "_deserialize", + "_sel", + "_joinsel", + "_supportfn", + "_analyze", + "_typmod_in", + "_typmod_out", + "_in", + "_out", + "_recv", + "_send", + # PG btree opclass support — user-callable but only meaningful inside + # PG operator classes for sorting and hash. Spark uses Dataset.distinct + # / orderBy which works on hex-WKB string equality natively. + "_cmp", + "_eq", + "_ne", + "_lt", + "_le", + "_gt", + "_ge", + "_hash", + "_hash_extended", +) + + +# PG-specific / PG-extension-specific entry points with no portable equivalent. +# Excluded from the audit; do not register as UDFs. +# +# NOTE: box2d / box3d ARE addressable here even though they're PostGIS types, +# because PostGIS is embedded in MEOS — the BOX3D / GBOX structs and their +# I/O functions are exported by libmeos.so. The ranges (range/multirange) +# are PG built-ins NOT in MEOS, so they remain OOS. +OUT_OF_SCOPE_NAMES = frozenset({ + # PostgreSQL built-in range types — NOT in MEOS, no portable equivalent + "range", # span → PG range type + "multirange", # spanset → PG multirange type + # PG-extension-specific data generators + "create_trip", # BerlinMOD synthetic-trajectory generator (PG-only, depends + # on BerlinMOD road-network schema + PG random functions) + # Platform-bridge functions + "transform_gk", # Gauss-Krüger projection used to interoperate with the + # SECONDO research platform; not portable to Spark/DuckDB +}) + + +def is_out_of_scope_name(fname): + lower = fname.lower() + if lower in OUT_OF_SCOPE_NAMES: + return True + for suf in OUT_OF_SCOPE_NAME_SUFFIXES: + if lower.endswith(suf) and len(lower) > len(suf): + return True + return False + + +def snake_to_camel(name): + """Convert MobilityDB snake_case to MobilitySpark camelCase. + + Examples: + tgeompoint_in → tgeompointIn + eintersects_tgeo_geo → eintersectsTgeoGeo + nad_tgeo_tgeo → nadTgeoTgeo + tdistance_tgeo_geo → tdistanceTgeoGeo + """ + parts = name.split("_") + if not parts: + return name + return parts[0] + "".join(p.capitalize() for p in parts[1:]) + + +CREATE_FUNC_RE = re.compile( + r"CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+(\w+)\s*\(([^)]*)\)", + re.IGNORECASE | re.DOTALL, +) +CREATE_OP_RE = re.compile(r"CREATE\s+OPERATOR\s+(\S+)\s*\(", re.IGNORECASE) + +# Spark UDF registration patterns. +REGISTER_RE = re.compile(r'spark\.udf\(\)\.register\s*\(\s*"([^"]+)"') + + +def collect_mobilitydb(mdb_root): + sql_root = os.path.join(mdb_root, "mobilitydb", "sql") + if not os.path.isdir(sql_root): + sys.exit(f"MobilityDB SQL dir not found: {sql_root}") + + section_funcs = collections.OrderedDict() + section_op_count = collections.OrderedDict() + all_funcs = set() + + for section in sorted(os.listdir(sql_root)): + full = os.path.join(sql_root, section) + if not os.path.isdir(full): + continue + for sql in sorted(glob.glob(f"{full}/*.in.sql")): + rel = os.path.relpath(sql, sql_root) + with open(sql) as f: + text = f.read() + funcs = collections.Counter() + for m in CREATE_FUNC_RE.finditer(text): + funcs[m.group(1)] += 1 + all_funcs.add(m.group(1)) + section_funcs[rel] = funcs + section_op_count[rel] = len(CREATE_OP_RE.findall(text)) + + return section_funcs, section_op_count, all_funcs + + +def collect_mobilityspark(mspark_root): + src_root = os.path.join(mspark_root, "src", "main", "java") + if not os.path.isdir(src_root): + sys.exit(f"MobilitySpark src dir not found: {src_root}") + + funcs = collections.Counter() + files_for_func = collections.defaultdict(set) + for java in glob.glob(f"{src_root}/**/*.java", recursive=True): + with open(java, errors="replace") as f: + text = f.read() + rel = os.path.relpath(java, src_root) + for m in REGISTER_RE.finditer(text): + funcs[m.group(1)] += 1 + files_for_func[m.group(1)].add(rel) + return funcs, files_for_func + + +def is_deferred(section_relpath): + family = section_relpath.split("/", 1)[0] + return family in DEFERRED_FAMILIES + + +def is_out_of_scope_section(section_relpath): + return section_relpath in OUT_OF_SCOPE_SECTIONS + + +# Known MobilitySpark type-prefixes used by registered UDFs. A SQL function +# `abs(tnumber)` is covered if any Spark UDF named e.g. `tnumberAbs`, +# `tintAbs`, `tfloatAbs` exists. The match strips one of these prefixes +# and compares the remainder (case-insensitive). +TYPE_PREFIXES = ( + "tnumber", "tpoint", "tgeompoint", "tgeogpoint", + "tgeo", "tgeometry", "tgeography", + "tfloat", "tint", "tbool", "ttext", + "tbox", "stbox", + "span", "spanset", "set", + "tcbuffer", "tnpoint", "tpose", "trgeo", + "temporal", "geo", "geom", "geog", +) + + +def write_report(out_path, mdb_section_funcs, mdb_section_op_count, + all_mdb_funcs, mspark_funcs): + # Build case-insensitive lookup of registered Spark UDF names. + mspark_funcs_lower = {k.lower(): k for k in mspark_funcs} + + # Build loose-match index: for each Spark UDF, also index its name + # with known type-prefixes stripped. So `tnumberAbs` becomes + # discoverable by the bare name `abs`, `tpointSRID` by `srid`, etc. + loose_index = set() + for k in mspark_funcs: + kl = k.lower() + loose_index.add(kl) + for pfx in TYPE_PREFIXES: + if kl.startswith(pfx) and len(kl) > len(pfx): + loose_index.add(kl[len(pfx):]) + + # Build a list of Spark UDF names sorted by length (longest first) for + # efficient prefix scanning. + mspark_lower_list = sorted(mspark_funcs_lower.keys(), key=len, reverse=True) + + # Known MobilitySpark type-SUFFIX tokens that may be appended to a + # MobilityDB camel-case name to disambiguate overloads. Match is + # case-insensitive on the camelCase form. + TYPE_SUFFIXES = ( + "tintint", "tfloatfloat", "tboolbool", "ttexttext", + "tnumbertnumber", "ttempt", "temporaltemporal", + "tgeotgeo", "tgeogeo", "tgeotgeompoint", + "tpointtpoint", "tpointgeo", "tpointpoint", + "tcbuffertcbuffer", "tcbuffergeo", + "tnpointtnpoint", "tnpointgeo", + "tposetpose", "tposegeo", + "trgeotrgeo", "trgeogeo", + "intint", "floatfloat", "textstring", "boolbool", + "tboxtbox", "stboxstbox", + "tinttbox", "tboxtint", "tfloattbox", "tboxtfloat", + "tnumbertbox", "tboxtnumber", + "tspatialstbox", "stboxtspatial", + "spanspan", "spansetspanset", "spansetspan", "spanspanset", + "setset", + "tint", "tfloat", "tbool", "ttext", "ttempt", "temporal", + "tgeo", "tpoint", "tcbuffer", "tnpoint", "tpose", "trgeo", + "tbox", "stbox", + "span", "spanset", "set", + "geo", "geom", "geog", "point", + "int", "float", "text", "bool", + ) + + # MobilityDB SQL "wrapper" prefixes that span multiple type combos. + # A name like `temporal_above` is a dispatcher over + # {above_stbox_tspatial, above_tspatial_stbox, above_tspatial_tspatial}, + # all of which appear in MobilitySpark with type-suffixed names like + # `stboxAboveTpoint`, `tpointAboveStbox`, `tpointAbove`. To recognise + # this, strip the wrapper prefix and check whether the remainder + # appears as a substring (case-insensitive) of any Spark UDF name. + WRAPPER_PREFIXES = ( + "temporal_", "tnumber_", "tspatial_", "tgeo_", "tpoint_", + ) + + def is_covered(mdb_fname): + """A MobilityDB SQL name is covered by MobilitySpark if any of: + 1. exact match (case-insensitive) on snake or camel form + 2. loose: name appears after stripping a known type-PREFIX from a + Spark UDF name (e.g. abs ↔ tnumberAbs) + 3. suffix: any Spark UDF starts with the camel-case form and + ends with a known type-SUFFIX (e.g. always_eq ↔ alwaysEqTintInt, + alwaysEqTfloatFloat, alwaysEqTemporal) + 4. wrapper: MobilityDB dispatcher name `_` is + considered covered if any Spark UDF contains `` (PascalCase) + — e.g. temporal_above ↔ stboxAboveTpoint / tpointAboveStbox.""" + camel = snake_to_camel(mdb_fname).lower() + bare = mdb_fname.lower() + if bare in mspark_funcs_lower or camel in mspark_funcs_lower: + return True + if bare in loose_index or camel in loose_index: + return True + for udf in mspark_lower_list: + if udf.startswith(camel) and len(udf) > len(camel): + tail = udf[len(camel):] + for suf in TYPE_SUFFIXES: + if tail == suf: + return True + # Wrapper match + for wpfx in WRAPPER_PREFIXES: + if bare.startswith(wpfx) and len(bare) > len(wpfx): + verb = bare[len(wpfx):] + # Avoid 1-letter false positives. + if len(verb) >= 3: + for udf in mspark_lower_list: + if verb in udf: + return True + return False + + active_results = [] + deferred_results = [] + out_of_scope_results = [] + + for sec, funcs in mdb_section_funcs.items(): + if not funcs: + continue + section_oos = is_out_of_scope_section(sec) + section_deferred = is_deferred(sec) + covered, missing, oos_names = [], [], [] + for fname, count in sorted(funcs.items()): + if section_oos: + oos_names.append((fname, count)) + continue + if not section_deferred and is_out_of_scope_name(fname): + oos_names.append((fname, count)) + continue + if is_covered(fname): + covered.append((fname, count)) + else: + missing.append((fname, count)) + addressable = len(covered) + len(missing) + pct = (len(covered) / addressable * 100) if addressable else 0 + row = (sec, len(funcs), len(covered), len(missing), pct, + missing, covered, mdb_section_op_count[sec], + oos_names, addressable) + if section_oos: + out_of_scope_results.append(row) + elif section_deferred: + deferred_results.append(row) + else: + active_results.append(row) + + def totals(results): + cov = sum(r[2] for r in results) + miss = sum(r[3] for r in results) + n = cov + miss + pct = (cov / n * 100) if n else 0 + return n, cov, miss, pct + + def oos_total(results): + return sum(len(r[8]) for r in results) + + a_total, a_cov, a_miss, a_pct = totals(active_results) + d_total, d_cov, d_miss, d_pct = totals(deferred_results) + a_oos_inside = oos_total(active_results) + section_oos_total = sum(len(r[8]) for r in out_of_scope_results) + total_oos = a_oos_inside + section_oos_total + + lines = [] + lines.append("# MobilitySpark parity status — surface-level audit") + lines.append("") + lines.append( + f"Generated {date.today().isoformat()}. **Active addressable scope** " + f"(temporal + geo, excluding PG-only helpers): " + f"{a_cov}/{a_total} names covered ({a_pct:.1f}%)." + ) + lines.append("") + lines.append( + f"**Out of scope** (PG-only — no Spark equivalent exists): " + f"{total_oos} names skipped — {section_oos_total} from PG-only " + f"sections (GiST/SPGiST opclasses, set/span/spanset index files, " + f"`019_geo_constructors.in.sql` PG geometric types, " + f"`999_oid_cache.in.sql`) plus {a_oos_inside} PG helper functions " + f"inside active sections (`*_in/_out/_recv/_send`, `*_transfn/" + f"_combinefn/_finalfn/_serialize/_deserialize`, `*_sel/_joinsel/" + f"_supportfn/_analyze`, `*_typmod_in/_typmod_out`). Listed in " + f"appendix B; not counted in the headline." + ) + lines.append("") + if DEFERRED_FAMILIES: + lines.append( + f"**Deferred families** ({', '.join(sorted(DEFERRED_FAMILIES))}) " + "appear in appendix C and are also excluded from the headline." + ) + else: + lines.append( + "**All six type families in scope** (temporal, geo, cbuffer, " + "npoint, pose, rgeo). None is deferred or excluded from the " + "headline — they are full user-facing temporal types covered " + "like every other family (RFC #920; MobilityDB#1075)." + ) + lines.append("") + lines.append( + "**Methodology**: parsed `CREATE FUNCTION` from " + "`mobilitydb/sql/**/*.in.sql` and `spark.udf().register(\"name\", " + "...)` (scalar + UDAF) from `MobilitySpark/src/main/java/**/*.java`. " + "Match is by **function name only**, case-insensitive; MobilityDB " + "snake_case is converted to camelCase before comparison so e.g. " + "`tdistance_tgeo_geo` matches `tdistanceTgeoGeo`. A name registered " + "in MobilitySpark is treated as covering all its overloads; " + "per-overload signature parity is not verified at this granularity." + ) + lines.append("") + lines.append("**Caveats**:") + lines.append( + "- A name match doesn't prove signature parity. e.g. " + "`before(temporal, temporal)` registered in MobilitySpark does not " + "necessarily cover MobilityDB's `before(tstzspan, temporal)`." + ) + lines.append( + "- Spark SQL has no infix-operator extension API; equivalent named " + "functions are registered. The `MDB operators` column lists how " + "many `CREATE OPERATOR` statements exist in the section, all of " + "which collapse to named-function form in MobilitySpark." + ) + lines.append("") + lines.append( + "Regenerate with `python3 scripts/parity-audit.py --mdb " + "../MobilityDB --mspark . --out docs/parity-status.md`. The " + "OUT_OF_SCOPE_SECTIONS / OUT_OF_SCOPE_NAME_SUFFIXES / " + "DEFERRED_FAMILIES sets at the top of that script control bucketing." + ) + lines.append("") + + lines.append("## Active-scope coverage summary (addressable surface)") + lines.append("") + lines.append("| Section | Addressable | Covered | Missing | Coverage | OOS | MDB operators |") + lines.append("|---|---:|---:|---:|---:|---:|---:|") + for sec, total, cov, miss, pct, _, _, ops, oos_names, addressable in active_results: + lines.append( + f"| `{sec}` | {addressable} | {cov} | {miss} | {pct:.0f}% | " + f"{len(oos_names)} | {ops} |" + ) + lines.append( + f"| **TOTAL (active)** | **{a_total}** | **{a_cov}** | " + f"**{a_miss}** | **{a_pct:.0f}%** | **{a_oos_inside}** | — |" + ) + lines.append("") + + lines.append("## Missing function names per active section") + lines.append("") + for sec, total, cov, miss, pct, missing, _, _, _, addressable in active_results: + if not missing: + continue + lines.append(f"### `{sec}` — {miss} missing of {addressable} addressable ({pct:.0f}% covered)") + lines.append("") + for fname, count in missing: + tag = f" ({count} overloads)" if count > 1 else "" + lines.append(f"- `{fname}` → `{snake_to_camel(fname)}`{tag}") + lines.append("") + + # ----- Appendix B: out-of-scope (PG-only) ----- + lines.append("## Appendix B — Out of scope (PG-only, no Spark equivalent)") + lines.append("") + lines.append( + "These entries are PG-specific helpers — index opclasses, " + "aggregate transition/combine/final/serialize callbacks, planner " + "hooks (`_sel`, `_joinsel`, `_supportfn`, `_analyze`), text/binary " + "I/O helpers (`_in`, `_out`, `_recv`, `_send`), type modifier " + "helpers, the `999_oid_cache` PG catalog hook, and PG geometric " + "type constructors (`019_geo_constructors`). None of them have " + "Spark equivalents and they should not be implemented; listed " + "here only for completeness." + ) + lines.append("") + if out_of_scope_results: + lines.append("### Whole sections excluded") + lines.append("") + lines.append("| Section | Names |") + lines.append("|---|---:|") + for sec, total, _, _, _, _, _, _, oos_names, _ in out_of_scope_results: + lines.append(f"| `{sec}` | {len(oos_names)} |") + lines.append("") + if a_oos_inside: + lines.append("### PG helpers inside active sections") + lines.append("") + lines.append("| Section | PG helpers |") + lines.append("|---|---:|") + for sec, _, _, _, _, _, _, _, oos_names, _ in active_results: + if oos_names: + lines.append(f"| `{sec}` | {len(oos_names)} |") + lines.append("") + + # ----- Appendix C: deferred families ----- + if deferred_results: + lines.append("## Appendix C — Deferred families") + lines.append("") + lines.append( + f"These families ({', '.join(sorted(DEFERRED_FAMILIES))}) are " + "deferred until the active temporal + geo surface stabilises. " + "Re-include by editing `DEFERRED_FAMILIES` at the top of " + "`scripts/parity-audit.py`. Listed here so the picture stays " + "complete; not counted in headline coverage." + ) + lines.append("") + lines.append("| Section | Addressable | Covered | Missing | Coverage |") + lines.append("|---|---:|---:|---:|---:|") + for sec, total, cov, miss, pct, _, _, _, _, addressable in deferred_results: + lines.append( + f"| `{sec}` | {addressable} | {cov} | {miss} | {pct:.0f}% |" + ) + lines.append( + f"| **TOTAL (deferred)** | **{d_total}** | **{d_cov}** | " + f"**{d_miss}** | **{d_pct:.0f}%** |" + ) + lines.append("") + + with open(out_path, "w") as f: + f.write("\n".join(lines) + "\n") + + return a_total, a_cov, a_pct + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--mdb", default="../MobilityDB", + help="Path to MobilityDB checkout (default ../MobilityDB)") + ap.add_argument("--mspark", default=".", + help="Path to MobilitySpark checkout (default .)") + ap.add_argument("--out", default="docs/parity-status.md", + help="Output path (default docs/parity-status.md)") + args = ap.parse_args() + + mdb_section_funcs, mdb_section_op_count, all_mdb_funcs = collect_mobilitydb(args.mdb) + mspark_funcs, _files = collect_mobilityspark(args.mspark) + + a_total, a_cov, a_pct = write_report( + args.out, mdb_section_funcs, mdb_section_op_count, + all_mdb_funcs, mspark_funcs, + ) + print(f"Wrote {args.out}") + print(f"Active addressable coverage: {a_cov}/{a_total} ({a_pct:.1f}%)") + + +if __name__ == "__main__": + main() diff --git a/scripts/portable_parity.py b/scripts/portable_parity.py new file mode 100644 index 00000000..ed27c0cb --- /dev/null +++ b/scripts/portable_parity.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""Portable bare-name parity gate for MobilitySpark. + +The MobilitySpark analogue of MobilityDB/MEOS-API `portable_parity.py` +(and of MobilityDB `tools/portable_aliases/generate.py --check`). Same +prefix logic, applied to the set of Spark-SQL UDF names MobilitySpark +registers. + +Single source of truth: the 29 operator -> bareName pairs in +`meta/portable-aliases.json` (vendored read-only from +MobilityDB/MEOS-API PR #8 / RFC #920). For every canonical bare name a +registered UDF *backs* it iff some registered name equals the bare name +or starts with `bareName + "_"`; failing that, the verified +`explicitBacking` C-family prefixes are tried (e.g. +`nearestApproachDistance` -> `nad`). A bare name with no match is +`needs-explicit-backing` (unbacked) — the precise worklist, never a +fabricated verdict. + +Done = 0 unbacked = 29/29 = 100%, across all six type families +(temporal, geo, cbuffer, npoint, pose, rgeo) — none excluded. + + python3 scripts/portable_parity.py # gate (exit 1 if unbacked) + python3 scripts/portable_parity.py --out FILE # also write JSON report + +Usage: + python3 scripts/portable_parity.py \\ + --mspark . --contract meta/portable-aliases.json +""" + +import argparse +import glob +import json +import os +import re +import sys + + +REGISTER_RE = re.compile(r'\.udf\(\)\.register\(\s*"([A-Za-z0-9_]+)"') + + +def registered_udf_names(mspark_root): + """Every name passed to spark.udf().register("name", ...) in src/main.""" + names = set() + pat = os.path.join(mspark_root, "src", "main", "java", "**", "*.java") + for path in glob.glob(pat, recursive=True): + with open(path, encoding="utf-8") as fh: + names.update(REGISTER_RE.findall(fh.read())) + return names + + +def build_parity(contract, names): + fam_of = {p["bareName"]: (fam, p["operator"]) + for fam, lst in contract["families"].items() for p in lst} + explicit = contract.get("explicitBacking", {}) + + def matches(prefix): + return sorted(n for n in names + if n == prefix or n.startswith(prefix + "_")) + + by_bare = {} + for bare, (fam, op) in sorted(fam_of.items()): + hits, via = matches(bare), "prefix" + if not hits: + for pref in explicit.get(bare, []): + hits += matches(pref) + via = "explicit" if hits else None + by_bare[bare] = { + "operator": op, "family": fam, "via": via, + "backedBy": len(hits), "sample": hits[:3], + "status": "backed" if hits else "needs-explicit-backing", + } + backed = [b for b, v in by_bare.items() if v["status"] == "backed"] + unbacked = sorted(b for b, v in by_bare.items() + if v["status"] == "needs-explicit-backing") + total = len(by_bare) + return { + "total": total, + "backed": len(backed), + "needsExplicitBacking": len(unbacked), + "parityPct": round(len(backed) * 100 / total, 1) if total else 0, + "unbacked": unbacked, + "byBareName": by_bare, + } + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--mspark", default=".", + help="MobilitySpark repo root (default: .)") + ap.add_argument("--contract", default="meta/portable-aliases.json", + help="path to vendored portable-aliases.json") + ap.add_argument("--out", default=None, + help="optional JSON report path") + args = ap.parse_args() + + contract_path = (args.contract if os.path.isabs(args.contract) + else os.path.join(args.mspark, args.contract)) + with open(contract_path, encoding="utf-8") as fh: + contract = json.load(fh) + + names = registered_udf_names(args.mspark) + rep = build_parity(contract, names) + + if args.out: + os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True) + with open(args.out, "w", encoding="utf-8") as fh: + json.dump(rep, fh, indent=2) + + print(f"[portable-parity] {rep['backed']}/{rep['total']} canonical bare " + f"names backed by a registered UDF ({rep['parityPct']}%); " + f"{rep['needsExplicitBacking']} unbacked", file=sys.stderr) + for b in rep["unbacked"]: + v = rep["byBareName"][b] + print(f" UNBACKED: {b!r} ({v['operator']}, {v['family']})", + file=sys.stderr) + + if rep["needsExplicitBacking"]: + print("CHECK: FAIL — portable bare-name parity < 100%", + file=sys.stderr) + return 1 + print(f"CHECK: PASS — {rep['total']}/{rep['total']} bare names backed, " + "0 unbacked, all six families", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/setup/generate_data.sh b/setup/generate_data.sh new file mode 100755 index 00000000..72874bef --- /dev/null +++ b/setup/generate_data.sh @@ -0,0 +1,169 @@ +#!/usr/bin/env bash +# Generate BerlinMOD CSV data for the cross-platform benchmark. +# +# Uses MobilityDB-BerlinMOD's data generator (PostgreSQL-based) to produce +# the shared CSV files that bench.sh loads into all three platforms. +# +# Usage: +# generate_data.sh [options] +# +# Options: +# --mobilitydbbm DIR Path to MobilityDB-BerlinMOD clone +# (default: auto-detect sibling of MobilitySpark) +# --scalefactor FLOAT BerlinMOD scale factor (default: 0.005) +# 0.005 → ~100 vehicles, ~10 000 trips (~15 min total) +# 0.05 → ~1000 vehicles, ~100 000 trips (~2–3 hours) +# --dbname NAME Temporary PostgreSQL database for generation +# (default: berlinmod_gen; dropped when done) +# --output DIR Where to write the CSV files +# (default: berlinmod/data/ inside this repo) +# --keep-db Keep the PostgreSQL database after export +# --skip-osm Skip the osm2pgrouting / brussels_preparedata steps +# (use when the road network is already loaded in --dbname) +# +# Requirements: +# psql + createdb + dropdb on PATH; MobilityDB + pgRouting installed. +# osm2pgrouting on PATH (sudo apt-get install osm2pgrouting). +# The script expects MobilityDB-BerlinMOD at the path given by +# --mobilitydbbm or auto-detected. + +set -euo pipefail +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)" + +# ── defaults ────────────────────────────────────────────────────────────────── +# Try to find MobilityDB-BerlinMOD next to this repo +AUTO_BM="$(cd "${REPO_ROOT}/.." && pwd)/MobilityDB-BerlinMOD" +BM_DIR="${AUTO_BM}" +SCALEFACTOR="0.005" +DBNAME="berlinmod_gen" +OUTPUT="${REPO_ROOT}/berlinmod/data" +KEEP_DB=false +SKIP_OSM=false + +while [[ $# -gt 0 ]]; do + case "$1" in + --mobilitydbbm) BM_DIR="$2"; shift 2 ;; + --scalefactor) SCALEFACTOR="$2"; shift 2 ;; + --dbname) DBNAME="$2"; shift 2 ;; + --output) OUTPUT="$2"; shift 2 ;; + --keep-db) KEEP_DB=true; shift ;; + --skip-osm) SKIP_OSM=true; shift ;; + *) echo "Unknown option: $1"; exit 1 ;; + esac +done + +BM_SQL="${BM_DIR}/BerlinMOD" + +if [[ ! -d "$BM_SQL" ]]; then + echo "ERROR: MobilityDB-BerlinMOD not found at: ${BM_DIR}" + echo "" + echo "Clone it first:" + echo " git clone https://github.com/MobilityDB/MobilityDB-BerlinMOD.git \\" + echo " ${BM_DIR}" + echo "" + echo "Then re-run this script." + exit 1 +fi + +# Check osm2pgrouting is present (needed for road network load) +if ! $SKIP_OSM && ! command -v osm2pgrouting >/dev/null 2>&1; then + echo "ERROR: osm2pgrouting not found on PATH." + echo "Install it: sudo apt-get install osm2pgrouting" + echo "Or skip the road network step if the database already has it:" + echo " $0 --skip-osm [other options]" + exit 1 +fi + +echo "╔══════════════════════════════════════════════════╗" +echo "║ BerlinMOD data generator ║" +echo "╚══════════════════════════════════════════════════╝" +echo "" +echo "Scale factor : ${SCALEFACTOR}" +echo "Database : ${DBNAME}" +echo "Output : ${OUTPUT}" +echo "" + +_psql() { psql -d "$DBNAME" -q "$@"; } + +# ── create database ─────────────────────────────────────────────────────────── +echo "=== Creating database: ${DBNAME} ===" +createdb "$DBNAME" 2>/dev/null || true +_psql -c "CREATE EXTENSION IF NOT EXISTS MobilityDB CASCADE;" +_psql -c "CREATE EXTENSION IF NOT EXISTS pgRouting CASCADE;" + +# ── load Brussels road network (osm2pgrouting + brussels_preparedata.sql) ───── +if ! $SKIP_OSM; then + echo "=== Loading Brussels road network from OSM (~2 min) ===" + OSM_FILE="${BM_SQL}/brussels.osm" + MAP_CONFIG="${BM_SQL}/mapconfig.xml" + if [[ ! -f "$OSM_FILE" ]]; then + echo "ERROR: brussels.osm not found at ${OSM_FILE}" + exit 1 + fi + DB_USER="${USER:-$(id -un)}" + osm2pgrouting --dbname "$DBNAME" -U "$DB_USER" \ + --file "$OSM_FILE" \ + --conf "$MAP_CONFIG" \ + --clean \ + 2>&1 | grep -E "Execution (started|ended)|Elapsed" + # osm2pgsql provides planet_osm_polygon needed by brussels_preparedata.sql + osm2pgsql -c -H localhost -U "$DB_USER" -d "$DBNAME" "$OSM_FILE" \ + 2>&1 | grep -v "^20[0-9][0-9]-" + echo "=== Preparing road network graph ===" + _psql -f "${BM_SQL}/brussels_preparedata.sql" +fi + +# ── run the BerlinMOD data generator ───────────────────────────────────────── +echo "=== Generating data (scalefactor=${SCALEFACTOR}) — this may take several minutes ===" +# Load function definitions (the activation call is commented out in the file) +_psql -f "${BM_SQL}/berlinmod_datagenerator.sql" +# Invoke the generator with the requested scale factor +_psql -c "SELECT berlinmod_generate(scaleFactor := ${SCALEFACTOR});" + +# ── export to shared CSV format ─────────────────────────────────────────────── +mkdir -p "$OUTPUT" +echo "" +echo "=== Exporting to CSV: ${OUTPUT} ===" +_psql -f "${BM_SQL}/berlinmod_export.sql" +_psql -c "SELECT berlinmod_portability_export('${OUTPUT}/');" + +# berlinmod_portability_export exports trips as WKT text (asText) and omits +# Periods/Regions. Override trips.csv with EWKB hex (required by MobilityDuck / +# MobilitySpark loaders) and add the two missing query fixtures. Also append +# the trip_h3 column (th3index hex-WKB at H3 resolution 7) so all three +# benchmarked platforms can read it directly without recomputing — the +# loaders fall back to recomputing if it's absent (legacy 3-column CSV). +_psql -c "COPY (SELECT TripId AS tripId, VehicleId AS vehId, + ashexewkb(Trip) AS trip, + asHexWKB(tgeompoint_to_th3index(Trip, 7)) AS trip_h3 + FROM Trips ORDER BY TripId) + TO '${OUTPUT}/trips.csv' DELIMITER ',' CSV HEADER;" +_psql -c "COPY (SELECT PeriodId AS periodId, period::text AS period FROM Periods ORDER BY PeriodId) TO '${OUTPUT}/query_periods.csv' DELIMITER ',' CSV HEADER;" +_psql -c "COPY (SELECT RegionId AS regionId, ST_AsText(ST_Transform(geom, 4326)) AS geom FROM Regions ORDER BY RegionId) TO '${OUTPUT}/query_regions.csv' DELIMITER ',' CSV HEADER;" + +# ── stats ───────────────────────────────────────────────────────────────────── +echo "" +echo "=== Dataset statistics ===" +_psql -c "SELECT count(*) AS vehicles FROM Vehicles;" +_psql -c "SELECT count(*) AS trips FROM Trips;" +echo "" +wc -l "${OUTPUT}"/*.csv + +# ── cleanup ─────────────────────────────────────────────────────────────────── +if $KEEP_DB; then + echo "" + echo "Database ${DBNAME} kept (--keep-db)." +else + echo "" + echo "=== Dropping temporary database: ${DBNAME} ===" + dropdb "$DBNAME" +fi + +echo "" +echo "╔══════════════════════════════════════════════════╗" +echo "║ Done. CSV files are in: ${OUTPUT}" +echo "╚══════════════════════════════════════════════════╝" +echo "" +echo "Run the benchmark:" +echo " ./berlinmod/bench/bench.sh --data ${OUTPUT}" diff --git a/setup/install_spark.sh b/setup/install_spark.sh new file mode 100644 index 00000000..78616819 --- /dev/null +++ b/setup/install_spark.sh @@ -0,0 +1,94 @@ +#!/usr/bin/env bash +# Install Apache Spark 3.5.x and Maven for the MobilitySpark benchmark. +# +# What this script does: +# 1. Installs Maven via apt (for building the MobilitySpark fat JAR) +# 2. Downloads Apache Spark 3.5.4 to /opt/spark-3.5.4 and creates +# a /opt/spark symlink +# 3. Adds SPARK_HOME and PATH entries to ~/.bashrc (or ~/.zshrc) +# +# After running this script, open a new shell (or source ~/.bashrc) and +# run the benchmark: +# cd /path/to/MobilitySpark +# mvn package -DskipTests -q +# ./berlinmod/bench/bench.sh --skip-mbdb --skip-mduck + +set -euo pipefail + +SPARK_VERSION="3.5.4" +SPARK_HADOOP="hadoop3" +INSTALL_DIR="/opt" +SPARK_TARBALL="spark-${SPARK_VERSION}-bin-${SPARK_HADOOP}.tgz" +SPARK_URL="https://archive.apache.org/dist/spark/spark-${SPARK_VERSION}/${SPARK_TARBALL}" + +SHELL_RC="${HOME}/.bashrc" +[[ "${SHELL}" == */zsh ]] && SHELL_RC="${HOME}/.zshrc" + +echo "╔══════════════════════════════════════════════════╗" +echo "║ MobilitySpark dependency installer ║" +echo "╚══════════════════════════════════════════════════╝" +echo "" + +# ── Maven ───────────────────────────────────────────────────────────────────── +if command -v mvn >/dev/null 2>&1; then + echo "[ok] Maven already installed: $(mvn --version | head -1)" +else + echo "=== Installing Maven ===" + sudo apt-get update -q + sudo apt-get install -y maven + echo "[ok] Maven installed: $(mvn --version | head -1)" +fi + +# ── Apache Spark ────────────────────────────────────────────────────────────── +SPARK_HOME="${INSTALL_DIR}/spark-${SPARK_VERSION}-bin-${SPARK_HADOOP}" +SPARK_LINK="${INSTALL_DIR}/spark" + +if [[ -x "${SPARK_LINK}/bin/spark-submit" ]]; then + echo "[ok] Spark already installed at ${SPARK_LINK}" +else + echo "" + echo "=== Downloading Apache Spark ${SPARK_VERSION} (~300 MB) ===" + TMP=$(mktemp -d) + trap 'rm -rf "$TMP"' EXIT + + curl -L --progress-bar "${SPARK_URL}" -o "${TMP}/${SPARK_TARBALL}" + + echo "=== Installing to ${SPARK_HOME} ===" + sudo tar -xzf "${TMP}/${SPARK_TARBALL}" -C "${INSTALL_DIR}" + sudo ln -sfn "${SPARK_HOME}" "${SPARK_LINK}" + echo "[ok] Spark installed: ${SPARK_HOME}" +fi + +# ── PATH / SPARK_HOME in shell rc ───────────────────────────────────────────── +if grep -q "SPARK_HOME=${INSTALL_DIR}/spark" "${SHELL_RC}" 2>/dev/null; then + echo "[ok] SPARK_HOME already in ${SHELL_RC}" +else + echo "" + echo "=== Adding SPARK_HOME to ${SHELL_RC} ===" + cat >> "${SHELL_RC}" << 'EOF' + +# Apache Spark (added by MobilitySpark setup/install_spark.sh) +export SPARK_HOME=/opt/spark +export PATH="$PATH:$SPARK_HOME/bin" +EOF + echo "[ok] Added SPARK_HOME=/opt/spark and PATH update to ${SHELL_RC}" +fi + +# ── Summary ─────────────────────────────────────────────────────────────────── +echo "" +echo "╔══════════════════════════════════════════════════╗" +echo "║ Installation complete ║" +echo "╚══════════════════════════════════════════════════╝" +echo "" +echo "Next steps:" +echo "" +echo " 1. Open a new shell (or run: source ${SHELL_RC})" +echo " 2. Build the MobilitySpark JAR:" +echo " cd $(cd "$(dirname "$0")/.." && pwd)" +echo " mvn package -DskipTests -q" +echo " 3. Run the benchmark:" +echo " ./berlinmod/bench/bench.sh --skip-mbdb --skip-mduck" +echo " Or all three platforms:" +echo " ./berlinmod/bench/bench.sh" +echo "" +echo "spark-submit is at: ${SPARK_LINK}/bin/spark-submit" diff --git a/src/main/java/org/mobilitydb/spark/MeosMemory.java b/src/main/java/org/mobilitydb/spark/MeosMemory.java new file mode 100644 index 00000000..82e0069e --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MeosMemory.java @@ -0,0 +1,84 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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 retained 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, INCIDENTAL, SPECIAL, EXEMPLARY, 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark; + +import jnr.ffi.Pointer; +import sun.misc.Unsafe; +import java.lang.reflect.Field; + +/** + * Native memory management for MEOS objects returned by JNR-FFI calls. + * + * MEOS standalone mode allocates temporal objects with the system malloc + * (palloc/pfree map to malloc/free when not running inside PostgreSQL). + * JNR-FFI Pointer values returned from MEOS functions are raw native + * addresses — they are NOT tracked by the Java GC. Callers must free + * each Pointer explicitly after use, otherwise the native heap grows + * without bound (one leaked Temporal* per UDF call × millions of rows + * in cross-join queries like Q2/Q4/Q5/Q6). + * + * Implementation uses sun.misc.Unsafe.freeMemory() which calls the system + * free() underneath — safe for MEOS pointers since MEOS standalone mode + * uses the system allocator. This avoids JNR-FFI classloader boundary + * issues that arise when loading libc via LibraryLoader inside Spark. + * + * Usage: + * 
+ *   Pointer tptr = functions.temporal_from_hexwkb(hex);
+ *   try {
+ *       // ... use tptr ...
+ *   } finally {
+ *       MeosMemory.free(tptr);
+ *   }
+ *
+ */ +public final class MeosMemory { + + private static final Unsafe UNSAFE; + static { + try { + Field f = Unsafe.class.getDeclaredField("theUnsafe"); + f.setAccessible(true); + UNSAFE = (Unsafe) f.get(null); + } catch (ReflectiveOperationException e) { + throw new ExceptionInInitializerError(e); + } + } + + private MeosMemory() {} + + /** Free a native pointer allocated by MEOS. Null-safe. */ + public static void free(Pointer ptr) { + if (ptr != null) UNSAFE.freeMemory(ptr.address()); + } + + /** Free multiple native pointers in one call. Null-safe. */ + public static void free(Pointer... ptrs) { + for (Pointer p : ptrs) { + if (p != null) UNSAFE.freeMemory(p.address()); + } + } +} diff --git a/src/main/java/org/mobilitydb/spark/MeosNative.java b/src/main/java/org/mobilitydb/spark/MeosNative.java new file mode 100644 index 00000000..8102d754 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MeosNative.java @@ -0,0 +1,345 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark; + +import jnr.ffi.LibraryLoader; +import jnr.ffi.Pointer; + +/** + * Supplementary JNR-FFI interface for libmeos symbols not yet declared in + * JMEOS-1.4. JMEOS-1.4 was generated from an older API snapshot and still + * uses {@code _tpoint_} naming for functions that MEOS 1.4 has renamed to + * {@code _tspatial_} or {@code _tgeo_}. + * + * Loading the same "meos" library twice is safe: JNR-FFI caches native + * library handles by name so the OS shared-library is opened only once. + */ +public final class MeosNative { + + private MeosNative() {} + + public interface Lib { + + // ---------------------------------------------------------------- + // Nearest approach distance (NAD) — returns double, DBL_MAX on fail + // ---------------------------------------------------------------- + + double nad_tgeo_geo(Pointer temporal, Pointer geo); + double nad_tgeo_stbox(Pointer temporal, Pointer stbox); + double nad_tgeo_tgeo(Pointer temporal1, Pointer temporal2); + + // ---------------------------------------------------------------- + // Nearest approach instant (NAI) — returns TInstant * + // ---------------------------------------------------------------- + + Pointer nai_tgeo_geo(Pointer temporal, Pointer geo); + Pointer nai_tgeo_tgeo(Pointer temporal1, Pointer temporal2); + + // ---------------------------------------------------------------- + // Shortest line — returns GSERIALIZED * + // ---------------------------------------------------------------- + + Pointer shortestline_tgeo_geo(Pointer temporal, Pointer geo); + + // ---------------------------------------------------------------- + // Scalar value-to-bin (renamed from float_bucket / int_bucket) + // ---------------------------------------------------------------- + + double float_get_bin(double value, double size, double origin); + int int_get_bin(int value, int size, int origin); + + // ---------------------------------------------------------------- + // TBox expand (renamed from tbox_expand_float / tbox_expand_int) + // ---------------------------------------------------------------- + + Pointer tfloatbox_expand(Pointer tbox, double value); + Pointer tintbox_expand(Pointer tbox, int value); + + // ---------------------------------------------------------------- + // tgeometry / tgeography MFJSON constructors (not in JMEOS-1.4) + // ---------------------------------------------------------------- + + Pointer tgeometry_from_mfjson(String mfjson); + Pointer tgeography_from_mfjson(String mfjson); + + // ---------------------------------------------------------------- + // tgeometry / tgeography text constructors (not in JMEOS-1.4) + // ---------------------------------------------------------------- + + Pointer tgeometry_in(String wkt); + Pointer tgeography_in(String wkt); + + // ---------------------------------------------------------------- + // Temporal accessor (not in JMEOS-1.4) + // ---------------------------------------------------------------- + + int temporal_mem_size(Pointer temporal); + Pointer tgeompoint_to_tgeometry(Pointer p); + Pointer tgeogpoint_to_tgeography(Pointer p); + Pointer tgeometry_to_tgeompoint(Pointer p); + Pointer tgeography_to_tgeogpoint(Pointer p); + Pointer tgeometry_to_tgeography(Pointer p); + Pointer tgeography_to_tgeometry(Pointer p); + + // Time-restriction (TimestampTz = int64 microseconds since J2000) + Pointer temporal_before_timestamptz(Pointer temporal, long pgEpochMicros); + Pointer temporal_after_timestamptz(Pointer temporal, long pgEpochMicros); + + // ttext concatenation (not in JMEOS-1.4) + Pointer textcat_ttext_text(Pointer ttext, Pointer text); + Pointer textcat_text_ttext(Pointer text, Pointer ttext); + Pointer textcat_ttext_ttext(Pointer ttext1, Pointer ttext2); + + // MobilityDB extension introspection + String mobilitydb_version(); + String mobilitydb_full_version(); + + // Typed set element accessors (return bool, fill out-param) + boolean intset_value_n(Pointer set, int n, Pointer result); + boolean bigintset_value_n(Pointer set, int n, Pointer result); + boolean floatset_value_n(Pointer set, int n, Pointer result); + + // Aggregate-as-scalar + double tnumber_avg_value(Pointer temporal); + + // tgeometry/tgeography instant constructor (geometry-typed, timestamp via long) + Pointer tgeoinst_make(Pointer geo, long pgEpochMicros); + + // Array-returning bbox accessors (count via out-param, returned + // pointer is contiguous TBox[]/STBox[] respectively) + Pointer tnumber_tboxes(Pointer temporal, Pointer count); + Pointer tgeo_stboxes(Pointer temporal, Pointer count); + + // Similarity paths (Match[] = pairs of {int i, int j}, 8 bytes each) + Pointer temporal_dyntimewarp_path(Pointer p1, Pointer p2, Pointer count); + Pointer temporal_frechet_path(Pointer p1, Pointer p2, Pointer count); + + // Affine transformation (AFFINE = 12 doubles, 96 bytes) + Pointer tgeo_affine(Pointer temporal, Pointer affine); + + // Span tiling — returns Span[] with count via out-param + Pointer intspan_bins(Pointer span, int vsize, int vorigin, Pointer count); + Pointer bigintspan_bins(Pointer span, long vsize, long vorigin, Pointer count); + Pointer floatspan_bins(Pointer span, double vsize, double vorigin, Pointer count); + + // Span expand (returns expanded Span*) + Pointer intspan_expand(Pointer span, int value); + Pointer bigintspan_expand(Pointer span, long value); + Pointer floatspan_expand(Pointer span, double value); + + // tpoint minus geometry, direction (instantaneous bearing in radians) + Pointer tpoint_minus_geom(Pointer temporal, Pointer geo); + boolean tpoint_direction(Pointer temporal, Pointer result); + + // Time-tiling: Span[] of consecutive time bins + Pointer temporal_time_bins(Pointer temporal, Pointer interval, long origin, Pointer count); + Pointer tstzspan_bins(Pointer span, Pointer interval, long origin, Pointer count); + + // Value-tiling: Span[] of consecutive value bins for tnumber + Pointer tint_value_bins(Pointer temporal, int vsize, int vorigin, Pointer count); + Pointer tfloat_value_bins(Pointer temporal, double vsize, double vorigin, Pointer count); + + // STBox quad-split: returns STBox[] of 4 quadrants (or 8 if Z, 16 if T) + Pointer stbox_quad_split(Pointer stbox, Pointer count); + + // Scalar timestamptz_get_bin: TimestampTz value, Interval, TimestampTz origin → TimestampTz + long timestamptz_get_bin(long ts, Pointer interval, long origin); + + // Single-point space tile: STBox of the cell containing point + Pointer stbox_get_space_tile(Pointer point, double xsize, double ysize, double zsize, Pointer sorigin); + Pointer stbox_get_time_tile(long t, Pointer duration, long torigin); + Pointer stbox_get_space_time_tile(Pointer point, long t, double xsize, double ysize, double zsize, Pointer duration, Pointer sorigin, long torigin); + + // Space + space-time bounding boxes (multi-tile, contiguous STBox[]) + Pointer tgeo_space_boxes(Pointer temporal, double xsize, double ysize, double zsize, Pointer sorigin, boolean bitmatrix, boolean border_inc, Pointer count); + Pointer tgeo_space_time_boxes(Pointer temporal, double xsize, double ysize, double zsize, Pointer duration, Pointer sorigin, long torigin, boolean bitmatrix, boolean border_inc, Pointer count); + + // tnumber value-time boxes (Datum vsize/vorigin passed as long) + Pointer tnumber_value_time_boxes(Pointer temporal, long vsize, Pointer duration, long vorigin, long torigin, Pointer count); + + // Splits — return Temporal** (array of pointers) + various out-bin arrays + Pointer temporal_time_split(Pointer temporal, Pointer duration, long torigin, Pointer time_bins_out, Pointer count); + Pointer tgeo_space_split(Pointer temporal, double xsize, double ysize, double zsize, Pointer sorigin, boolean bitmatrix, boolean border_inc, Pointer space_bins_out, Pointer count); + Pointer tgeo_space_time_split(Pointer temporal, double xsize, double ysize, double zsize, Pointer duration, Pointer sorigin, long torigin, boolean bitmatrix, boolean border_inc, Pointer space_bins_out, Pointer time_bins_out, Pointer count); + + // valueSet support: temporal_values_p returns Datum*, set_make_free + // packs them into a typed Set; temptype_basetype maps temporal type + // (T_TINT/T_TFLOAT/etc.) to its base value type (T_INT4/T_FLOAT8/etc.). + Pointer temporal_values_p(Pointer temporal, Pointer count); + int temptype_basetype(int temptype); + Pointer set_make_free(Pointer values, int count, int basetype, boolean order); + + // segmentMin/MaxDuration — temporal_segm_duration with atleast flag + Pointer temporal_segm_duration(Pointer temporal, Pointer duration, boolean atleast, boolean strict); + + // STBox → BOX3D / GBOX + text serialization (PostGIS embedded in MEOS) + Pointer stbox_to_box3d(Pointer stbox); + String box3d_out(Pointer box3d, int maxdd); + Pointer stbox_to_gbox(Pointer stbox); + String gbox_out(Pointer gbox, int maxdd); + + // Tile-set generators (return arrays of bounding boxes) + Pointer stbox_space_tiles(Pointer bounds, double xsize, double ysize, double zsize, Pointer sorigin, boolean border_inc, Pointer count); + Pointer stbox_time_tiles(Pointer bounds, Pointer duration, long torigin, boolean border_inc, Pointer count); + Pointer stbox_space_time_tiles(Pointer bounds, double xsize, double ysize, double zsize, Pointer duration, Pointer sorigin, long torigin, boolean border_inc, Pointer count); + Pointer tintbox_time_tiles(Pointer box, Pointer duration, long torigin, Pointer count); + Pointer tfloatbox_time_tiles(Pointer box, Pointer duration, long torigin, Pointer count); + Pointer tintbox_value_time_tiles(Pointer box, int xsize, Pointer duration, int xorigin, long torigin, Pointer count); + Pointer tfloatbox_value_time_tiles(Pointer box, double vsize, Pointer duration, double vorigin, long torigin, Pointer count); + + // tpoint → array of simple sub-tpoints (no self-intersections) + Pointer tpoint_make_simple(Pointer temporal, Pointer count); + + // Type-converters for timeBoxes intermediate step + Pointer tnumber_to_tbox(Pointer temporal); + + // Value-only tile generators (TBox[]) + Pointer tintbox_value_tiles(Pointer box, int xsize, int xorigin, Pointer count); + Pointer tfloatbox_value_tiles(Pointer box, double vsize, double vorigin, Pointer count); + + // Value/value-time splits returning Temporal** + bin out-arrays (Datum vsize/vorigin) + Pointer tnumber_value_split(Pointer temporal, long vsize, long vorigin, Pointer bins_out, Pointer count); + Pointer tnumber_value_time_split(Pointer temporal, long size, Pointer duration, long vorigin, long torigin, Pointer value_bins_out, Pointer time_bins_out, Pointer count); + + // Single-tile lookup: takes Datum value/origin + MeosType basetype/spantype + Pointer tbox_get_value_time_tile(long value, long t, long vsize, Pointer duration, long vorigin, long torigin, int basetype, int spantype); + + // tpoint analytics + boolean tpoint_tfloat_to_geomeas(Pointer tpoint, Pointer measure, boolean segmentize, Pointer result_out); + boolean tpoint_as_mvtgeom(Pointer temporal, Pointer bounds, int extent, int buffer, boolean clip_geom, Pointer gsarr_out, Pointer timesarr_out, Pointer count_out); + + // Split-by-N functions (count via out-param, returned pointer is contiguous array) + Pointer temporal_split_n_spans(Pointer temporal, int n, Pointer count); + Pointer temporal_split_each_n_spans(Pointer temporal, int n, Pointer count); + Pointer tnumber_split_n_tboxes(Pointer temporal, int n, Pointer count); + Pointer tnumber_split_each_n_tboxes(Pointer temporal, int n, Pointer count); + Pointer tgeo_split_n_stboxes(Pointer temporal, int n, Pointer count); + Pointer tgeo_split_each_n_stboxes(Pointer temporal, int n, Pointer count); + + // ---------------------------------------------------------------- + // Cross-type: STBox × TSpatial (spatial direction) + // ---------------------------------------------------------------- + + boolean left_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean right_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overleft_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overright_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean above_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean below_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overabove_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overbelow_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean front_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean back_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overfront_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overback_stbox_tspatial(Pointer stbox, Pointer tspatial); + + // ---------------------------------------------------------------- + // Cross-type: STBox × TSpatial (temporal direction) + // ---------------------------------------------------------------- + + boolean before_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean after_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overbefore_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overafter_stbox_tspatial(Pointer stbox, Pointer tspatial); + + // ---------------------------------------------------------------- + // Cross-type: STBox × TSpatial (topological) + // ---------------------------------------------------------------- + + boolean adjacent_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean contains_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean contained_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean overlaps_stbox_tspatial(Pointer stbox, Pointer tspatial); + boolean same_stbox_tspatial(Pointer stbox, Pointer tspatial); + + // ---------------------------------------------------------------- + // Cross-type: TSpatial × STBox (spatial direction) + // ---------------------------------------------------------------- + + boolean left_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean right_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overleft_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overright_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean above_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean below_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overabove_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overbelow_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean front_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean back_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overfront_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overback_tspatial_stbox(Pointer tspatial, Pointer stbox); + + // ---------------------------------------------------------------- + // Cross-type: TSpatial × STBox (temporal direction) + // ---------------------------------------------------------------- + + boolean before_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean after_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overbefore_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overafter_tspatial_stbox(Pointer tspatial, Pointer stbox); + + // ---------------------------------------------------------------- + // Cross-type: TSpatial × STBox (topological) + // ---------------------------------------------------------------- + + boolean adjacent_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean contains_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean contained_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean overlaps_tspatial_stbox(Pointer tspatial, Pointer stbox); + boolean same_tspatial_stbox(Pointer tspatial, Pointer stbox); + + // ---------------------------------------------------------------- + // Exact spatial-minimum distance (MobilityDB PR #1007) — returns + // double, DBL_MAX on failure. Threshold-aware: caller passes the + // running min (DBL_MAX for an unbounded first call) and the + // kernel short-circuits any pair whose lower bound already meets + // or exceeds it. Distinct from `nad_tgeo_tgeo` which is the + // time-synchronous (NAD) variant. + // ---------------------------------------------------------------- + + double mindistance_tgeo_tgeo(Pointer temporal1, Pointer temporal2, + double threshold); + + // Array form: minimum spatial distance over all pairs from two + // temporal-geo arrays. Pairs are visited in bbox-distance order + // and iteration short-circuits once the running min provably + // dominates every remaining pair's lower bound. + double tgeoarr_tgeoarr_mindist(Pointer arr1, int count1, + Pointer arr2, int count2); + } + + public static final Lib INSTANCE; + static { + LibraryLoader loader = LibraryLoader.create(Lib.class); + String libPath = System.getProperty("java.library.path"); + if (libPath != null) { + for (String p : libPath.split(":")) { + if (!p.isEmpty()) loader.search(p); + } + } + INSTANCE = loader.load("meos"); + } +} diff --git a/src/main/java/org/mobilitydb/spark/MeosThread.java b/src/main/java/org/mobilitydb/spark/MeosThread.java new file mode 100644 index 00000000..9b23cd13 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MeosThread.java @@ -0,0 +1,81 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark; + +import functions.functions; +import org.apache.spark.sql.api.java.*; + +/** + * Per-thread MEOS initialisation for Spark executor threads. + * + * In Spark's multi-threaded executor model every task thread must initialise + * MEOS independently because session_timezone and the timezone cache are + * thread-local inside libmeos. The ThreadLocal in MEOS_READY ensures + * initialisation runs exactly once per native thread. + * + * Usage — two patterns: + * + * 1. Wrap lambdas at registration time (preferred — no boilerplate in the + * lambda body and impossible to forget): + * spark.udf().register("foo", MeosThread.wrap((String s) -> ...), Type); + * + * 2. Call ensureReady() explicitly at the top of a lambda where wrapping is + * not convenient. + */ +public final class MeosThread { + + private MeosThread() {} + + private static final ThreadLocal MEOS_READY = ThreadLocal.withInitial(() -> { + functions.meos_initialize(); + functions.meos_initialize_timezone("UTC"); + functions.meos_initialize_noexit_error_handler(); + return Boolean.TRUE; + }); + + /** Ensure MEOS is initialised for the calling thread. */ + public static void ensureReady() { + MEOS_READY.get(); + } + + // ------------------------------------------------------------------ + // UDF wrappers — call ensureReady() before delegating to the lambda. + // Use these in registerAll() instead of scattering ensureReady() calls + // inside every individual UDF method body. + // ------------------------------------------------------------------ + + public static UDF1 wrap(UDF1 udf) { + return s -> { ensureReady(); return udf.call(s); }; + } + + public static UDF2 wrap(UDF2 udf) { + return (s, a) -> { ensureReady(); return udf.call(s, a); }; + } + + public static UDF3 wrap(UDF3 udf) { + return (s, a, b) -> { ensureReady(); return udf.call(s, a, b); }; + } +} diff --git a/src/main/java/org/mobilitydb/spark/MobilitySparkSession.java b/src/main/java/org/mobilitydb/spark/MobilitySparkSession.java new file mode 100644 index 00000000..fef4352a --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MobilitySparkSession.java @@ -0,0 +1,172 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark; + +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.geo.DistanceUDFs; +import org.mobilitydb.spark.geo.GeoAnalyticsUDFs; +import org.mobilitydb.spark.geo.GeoUDFs; +import org.mobilitydb.spark.geo.STBoxUDFs; +import org.mobilitydb.spark.geo.StaticGeoUDFs; +import org.mobilitydb.spark.geo.AlwaysSpatialRelsUDFs; +import org.mobilitydb.spark.geo.GeoAffineUDFs; +import org.mobilitydb.spark.geo.TempSpatialRelsUDFs; +import org.mobilitydb.spark.geo.TPointSTBoxOpsUDFs; +import org.mobilitydb.spark.temporal.AccessorAliasUDFs; +import org.mobilitydb.spark.temporal.AccessorUDFs; +import org.mobilitydb.spark.temporal.TileUDFs; +import org.mobilitydb.spark.temporal.SeqSetGapsUDFs; +import org.mobilitydb.spark.temporal.AnalyticsUDFs; +import org.mobilitydb.spark.temporal.BoolOpsUDFs; +import org.mobilitydb.spark.temporal.BucketUDFs; +import org.mobilitydb.spark.temporal.ConstructorUDFs; +import org.mobilitydb.spark.temporal.MathUDFs; +import org.mobilitydb.spark.temporal.PosOpsUDFs; +import org.mobilitydb.spark.temporal.PredicateUDFs; +import org.mobilitydb.spark.temporal.SimilarityUDFs; +import org.mobilitydb.spark.temporal.SpanAccessorUDFs; +import org.mobilitydb.spark.temporal.SpanAlgebraUDFs; +import org.mobilitydb.spark.temporal.SpanUDFs; +import org.mobilitydb.spark.temporal.IOAliasUDFs; +import org.mobilitydb.spark.temporal.SpansetOpsUDFs; +import org.mobilitydb.spark.temporal.SetOpsUDFs; +import org.mobilitydb.spark.temporal.SubtypeConstructorUDFs; +import org.mobilitydb.spark.temporal.AggregateUDAFs; +import org.mobilitydb.spark.temporal.MoreAccessorUDFs; +import org.mobilitydb.spark.temporal.RestrictionUDFs; +import org.mobilitydb.spark.temporal.TBoxOpsUDFs; +import org.mobilitydb.spark.temporal.TBoxUDFs; +import org.mobilitydb.spark.temporal.TemporalBoxOpsUDFs; +import org.mobilitydb.spark.temporal.TemporalCompUDFs; +import org.mobilitydb.spark.temporal.TTextUDFs; +import org.mobilitydb.spark.temporal.TemporalUDFs; +import org.mobilitydb.spark.temporal.TransformUDFs; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.concurrent.atomic.AtomicBoolean; + +import static functions.functions.*; + +/** + * Entry point for MobilitySpark. + * + * Initialises MEOS and registers all UDFs with the given SparkSession. + * Call {@link #create(SparkSession)} before running any temporal SQL, + * and {@link #close()} after (or use try-with-resources). + * + * 
{@code
+ *   SparkSession spark = SparkSession.builder().master("local[2]").getOrCreate();
+ *   try (MobilitySparkSession ms = MobilitySparkSession.create(spark)) {
+ *       spark.sql("SELECT atTime(trip, instant) FROM trips").show();
+ *   }
+ * }
+ */ +public final class MobilitySparkSession implements AutoCloseable { + + private static final AtomicBoolean SRS_CSV_REGISTERED = new AtomicBoolean(false); + + private MobilitySparkSession() {} + + public static MobilitySparkSession create(SparkSession spark) { + meos_initialize(); + meos_initialize_timezone("UTC"); + meos_initialize_noexit_error_handler(); + registerSpatialRefSys(); + TemporalUDFs.registerAll(spark); + SpanUDFs.registerAll(spark); + GeoUDFs.registerAll(spark); + GeoAnalyticsUDFs.registerAll(spark); + StaticGeoUDFs.registerAll(spark); + DistanceUDFs.registerAll(spark); + ConstructorUDFs.registerAll(spark); + AccessorUDFs.registerAll(spark); + SpanAccessorUDFs.registerAll(spark); + SpanAlgebraUDFs.registerAll(spark); + SpansetOpsUDFs.registerAll(spark); + IOAliasUDFs.registerAll(spark); + SubtypeConstructorUDFs.registerAll(spark); + AccessorAliasUDFs.registerAll(spark); + TileUDFs.registerAll(spark); + SeqSetGapsUDFs.registerAll(spark); + SetOpsUDFs.registerAll(spark); + AnalyticsUDFs.registerAll(spark); + PredicateUDFs.registerAll(spark); + TBoxUDFs.registerAll(spark); + TBoxOpsUDFs.registerAll(spark); + TemporalCompUDFs.registerAll(spark); + TemporalBoxOpsUDFs.registerAll(spark); + TTextUDFs.registerAll(spark); + STBoxUDFs.registerAll(spark); + PosOpsUDFs.registerAll(spark); + MathUDFs.registerAll(spark); + BoolOpsUDFs.registerAll(spark); + BucketUDFs.registerAll(spark); + SimilarityUDFs.registerAll(spark); + TempSpatialRelsUDFs.registerAll(spark); + AlwaysSpatialRelsUDFs.registerAll(spark); + GeoAffineUDFs.registerAll(spark); + TPointSTBoxOpsUDFs.registerAll(spark); + MoreAccessorUDFs.registerAll(spark); + RestrictionUDFs.registerAll(spark); + TransformUDFs.registerAll(spark); + AggregateUDAFs.registerAll(spark); + org.mobilitydb.spark.h3.Th3IndexUDFs.registerAll(spark); + // Portable bare-name operator dialect (RFC #920) — registered last + // so the 29 canonical bare names are the authoritative spelling. + org.mobilitydb.spark.portable.PortableOperatorAliasUDFs.registerAll(spark); + return new MobilitySparkSession(); + } + + /** + * Extracts the bundled spatial_ref_sys.csv to a temp file and registers + * it with MEOS so that geodetic coordinate operations (e.g. length on + * tgeogpoint) can look up SRID definitions without a PostGIS installation. + * Only runs once per JVM; subsequent calls are no-ops. + */ + private static void registerSpatialRefSys() { + if (!SRS_CSV_REGISTERED.compareAndSet(false, true)) return; + try (InputStream in = MobilitySparkSession.class + .getResourceAsStream("/spatial_ref_sys.csv")) { + if (in == null) return; + File tmp = File.createTempFile("meos_spatial_ref_sys", ".csv"); + tmp.deleteOnExit(); + try (OutputStream out = new FileOutputStream(tmp)) { + byte[] buf = new byte[65536]; + int n; + while ((n = in.read(buf)) > 0) out.write(buf, 0, n); + } + meos_set_spatial_ref_sys_csv(tmp.getAbsolutePath()); + } catch (Exception ignored) {} + } + + @Override + public void close() { + meos_finalize(); + } +} diff --git a/src/main/java/org/mobilitydb/spark/demo/BerlinMODBench.java b/src/main/java/org/mobilitydb/spark/demo/BerlinMODBench.java new file mode 100644 index 00000000..167afaee --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/demo/BerlinMODBench.java @@ -0,0 +1,418 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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 retained 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, INCIDENTAL, SPECIAL, EXEMPLARY, 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.demo; + +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.MobilitySparkSession; + +import java.io.IOException; +import java.io.PrintWriter; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.time.Instant; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * BerlinMOD benchmark runner for MobilitySpark. + * + * Loads the shared CSV dataset once (caching tables in Spark), then runs each + * BerlinMOD portable SQL query {@code runs} times and records wall-clock time + * per run. Writes a JSON file with per-query timing lists, compatible with + * the bench/report.py report generator. + * + * Usage: + * 
+ *   spark-submit --class org.mobilitydb.spark.demo.BerlinMODBench \
+ *       target/mobilityspark-*-spark.jar  data_dir  output.json  [runs]
+ *
+ * + * Args: + * data_dir — directory containing vehicles.csv, trips.csv, … + * output — path to write the timing JSON file + * runs — number of timed runs per query (default: 3) + * + * The SQL files are read from the same directory that contains this JAR's + * class path. If running from the repository root, pass + * {@code berlinmod/} as the SQL directory via the system property + * {@code berlinmod.sql.dir} (default: {@code berlinmod/}). + */ +public final class BerlinMODBench { + + private static final String[] QUERY_ORDER = { + "q01", "q02", "q03", "q04", "q05", "q06", "q07", "q08", "qrt", + "q09", "q10", "q11", "q12", "q13", "q14", "q15", "q16", "q17" + }; + + public static void main(String[] args) throws Exception { + if (args.length < 2) { + System.err.println("Usage: BerlinMODBench [runs] [queries]"); + System.err.println(" queries — page-range syntax: '3', '2-5', 'q02', 'q02-q05', 'qrt'"); + System.exit(1); + } + String dataDir = args[0]; + String outputPath = args[1]; + int runs = args.length >= 3 ? Integer.parseInt(args[2]) : 3; + String queryRange = args.length >= 4 ? args[3] : null; + + // Resolve which queries to run from the page-range argument. + // Accepted forms: "3", "2-5", "q02", "q02-q05", "qrt", "q04,qrt,q07" + List queryList = resolveQueryRange(queryRange); + + // SQL files live next to the berlinmod/data/ directory + String sqlDir = Paths.get(dataDir).getParent() != null + ? Paths.get(dataDir).getParent().toString() + : "."; + // Allow override via system property + sqlDir = System.getProperty("berlinmod.sql.dir", sqlDir); + + SparkSession spark = SparkSession.builder() + .appName("MobilitySpark — BerlinMOD Benchmark") + .config("spark.sql.legacy.createHiveTableByDefault", "false") + .getOrCreate(); + spark.sparkContext().setLogLevel("WARN"); + + System.out.println("=== BerlinMODBench: " + runs + " run(s) per query ==="); + + // Pre-load any existing results so a partial run can be resumed + // without losing previously collected timings. + Map> timings = loadExistingTimings(outputPath); + String version = "unknown"; + + try (MobilitySparkSession ms = MobilitySparkSession.create(spark)) { + // Register BerlinMOD-specific UDFs (length, bboxOverlaps, valueAtTimestamp, etc.) + BerlinMODUDFs.registerAll(spark); + + // Load and cache all tables — loading time is NOT in the query timings + System.out.println("=== Loading data from: " + dataDir + " ==="); + BerlinMODDemo.loadFromCsvPublic(spark, dataDir); + + // Materialise the th3index column on Trips at load time. Each trip's + // tgeompoint is converted to a temporal H3 cell sequence at the + // chosen resolution (default 7 ≈ 1.2 km cells). The trip_h3 column + // is used by the portable BerlinMOD SQL (Q4 / Q5 / Q6 / Q10) as a + // spatial prefilter — a cheap cell-membership test that runs before + // the expensive eIntersects / nearestApproachDistance / eDwithin / + // tDwithin calls. All three benchmarked platforms compute the + // column at load time so the comparison is apples-to-apples; on + // PostgreSQL the load script also adds a GiST index on the column + // so the prefilter becomes a true index seek. + // + // Disabled when berlinmod.bench.th3index.disable=true so before-vs- + // after measurement is reproducible without a rebuild — note that + // disabling it makes the prefilter expressions in the portable SQL + // reference a non-existent column, so use this only with a custom + // SQL set that omits the prefilter. + // + // If the source CSV already carries a trip_h3 column (as produced + // by berlinmod_portability_export() in MobilityDB-BerlinMOD), drop + // it first so we can rematerialise at our chosen resolution — this + // guarantees a consistent resolution across all three platforms + // regardless of how the CSV was produced. + if (!"true".equals(System.getProperty("berlinmod.bench.th3index.disable"))) { + int res = Integer.getInteger("berlinmod.bench.th3index.resolution", + org.mobilitydb.spark.h3.Th3IndexUDFs.DEFAULT_RESOLUTION); + System.out.println("=== Materialising trip_h3 column (resolution " + res + ") ==="); + String[] cols = spark.table("Trips").schema().fieldNames(); + String selectCols = java.util.Arrays.stream(cols) + .filter(c -> !"trip_h3".equalsIgnoreCase(c)) + .collect(Collectors.joining(", ")); + spark.sql( + "CREATE OR REPLACE TEMPORARY VIEW Trips AS " + + "SELECT " + selectCols + ", " + + " tgeompointToTh3Index(trip, " + res + ") AS trip_h3 " + + "FROM Trips" + ); + } + + spark.catalog().cacheTable("Vehicles"); + spark.catalog().cacheTable("Trips"); + spark.catalog().cacheTable("QueryLicences"); + spark.catalog().cacheTable("QueryInstants"); + spark.catalog().cacheTable("QueryPoints"); + spark.catalog().cacheTable("QueryRegions"); + spark.catalog().cacheTable("QueryPeriods"); + // Warm up the cache + spark.sql("SELECT count(*) FROM Trips").collect(); + System.out.println(" done."); + + // Try to capture version + try { + version = spark.sql("SELECT mobilitydb_version()") + .collectAsList().get(0).getString(0) + + " on Spark " + spark.version(); + } catch (Exception e) { + version = "MobilitySpark on Spark " + spark.version(); + } + + // Time each query — flush results after every query so a crash + // still leaves a valid JSON file with the timings collected so far. + for (String q : queryList) { + Path sqlFile = Paths.get(sqlDir, q + ".sql"); + if (!Files.exists(sqlFile)) { + System.out.printf(" [skip] %s — SQL file not found%n", q); + continue; + } + String sql = preprocessForSpark(stripComments(Files.readString(sqlFile))); + List qTimes = new ArrayList<>(runs); + + System.out.printf(" timing %-6s: ", q); + for (int run = 0; run < runs; run++) { + try { + long t0 = System.currentTimeMillis(); + spark.sql(sql).count(); // forces full evaluation + long elapsed = System.currentTimeMillis() - t0; + qTimes.add(elapsed); + System.out.printf("%d ", elapsed); + } catch (Exception e) { + String msg = e.getMessage(); + if (msg != null) msg = msg.split("\n")[0].substring(0, Math.min(120, msg.split("\n")[0].length())); + System.out.printf("[err:%s: %s] ", e.getClass().getSimpleName(), msg); + } + } + System.out.println("ms"); + if (!qTimes.isEmpty()) { + timings.put(q, qTimes); + writeJson(outputPath, version, dataDir, runs, timings); + } + } + } finally { + spark.stop(); + } + + System.out.println("=== Results written to " + outputPath + " ==="); + } + + /** Strip leading-comment lines so Spark SQL doesn't choke on them. */ + private static String stripComments(String sql) { + return Stream.of(sql.split("\n")) + .filter(line -> !line.stripLeading().startsWith("--")) + .collect(Collectors.joining("\n")) + .replaceAll(";\\s*$", ""); + } + + /** + * Rewrite portable BerlinMOD SQL to Spark-compatible SQL. + * + * Spark SQL cannot define custom infix operators, so the portable SQL's + * {@code &&} bounding-box overlap operator and PostgreSQL-specific cast + * syntax ({@code ::numeric}) must be rewritten before passing to + * {@link SparkSession#sql}. Transformations applied in order: + *
    + *
  1. {@code stbox(geom, t)} → {@code geoTimeStbox(geom, t)} (2-arg form only)
    2. + *
  2. {@code expr && expr2} → {@code bboxOverlaps(expr, expr2)} (per line)
    3. + *
  3. {@code ::numeric} → removed (Spark ROUND accepts DOUBLE directly)
    4. + *
  4. {@code ST_Contains(} → {@code geomContains(}
    5. + *
  5. th3index prefilter injection for {@code eIntersects(t., p.)} + * on point geometries — see {@link #injectTh3IndexPrefilter}.
    6. + *
+ */ + private static String preprocessForSpark(String sql) { + // 1. Replace 2-arg stbox(geom, time_or_period) with geoTimeStbox(geom, time_or_period). + // The \b word boundary ensures stboxHasx etc. are not affected. + // The [^,)]+ / [^)]+ pattern matches exactly 2 args (comma present). + sql = sql.replaceAll("\\bstbox\\(([^,)]+),\\s*([^)]+)\\)", "geoTimeStbox($1, $2)"); + + // 2. Replace bounding-box overlap operator && with the bboxOverlaps UDF. + // Pattern: table.column && right_hand_expr (rest of line). + sql = sql.replaceAll("([\\w]+\\.[\\w]+)\\s+&&\\s+(.+)", "bboxOverlaps($1, $2)"); + + // 3. Remove PostgreSQL :: cast to numeric (Spark ROUND handles DOUBLE natively). + sql = sql.replace("::numeric", ""); + + // 4. Replace PostGIS ST_Contains with the registered geomContains UDF. + sql = sql.replace("ST_Contains(", "geomContains("); + + // The th3index spatial prefilter for cross-join queries (Q4 / Q5 / + // Q6 / Q10) lives directly in the portable BerlinMOD SQL files (see + // the th3index unification work — every backend executes the same + // prefilter expressions, MobilitySpark via the Th3IndexUDFs class + // and the precomputed trip_h3 column on Trips). No Spark-specific + // injection rule is needed here. + + return sql; + } + + /** Write a JSON result file compatible with report.py. */ + private static void writeJson(String outputPath, + String version, + String dataDir, + int runs, + Map> timings) throws IOException { + // Count trips and vehicles from the timing data indirectly — just + // report what we know from disk. + long trips = countLines(Paths.get(dataDir, "trips.csv")) - 1; // minus header + long vehicles = countLines(Paths.get(dataDir, "vehicles.csv")) - 1; + + StringBuilder sb = new StringBuilder(); + sb.append("{\n"); + sb.append(" \"platform\": \"mobilityspark\",\n"); + sb.append(" \"version\": \"").append(escapeJson(version)).append("\",\n"); + sb.append(" \"data_vehicles\": ").append(vehicles).append(",\n"); + sb.append(" \"data_trips\": ").append(trips).append(",\n"); + sb.append(" \"runs\": ").append(runs).append(",\n"); + sb.append(" \"timestamp\": \"").append(Instant.now().toString()).append("\",\n"); + sb.append(" \"queries\": {\n"); + + // Emit in canonical QUERY_ORDER; any extra keys follow at the end. + List order = new ArrayList<>(java.util.Arrays.asList(QUERY_ORDER)); + for (String k : timings.keySet()) { if (!order.contains(k)) order.add(k); } + + boolean firstQ = true; + for (String q : order) { + if (!timings.containsKey(q)) continue; + if (!firstQ) sb.append(",\n"); + firstQ = false; + sb.append(" \"").append(q).append("\": ["); + sb.append(timings.get(q).stream() + .map(String::valueOf) + .collect(Collectors.joining(", "))); + sb.append("]"); + } + sb.append("\n }\n}\n"); + + // Atomic write: write to a .tmp file then rename so a crash mid-write + // never leaves a truncated JSON (the previous file stays intact). + Path dest = Paths.get(outputPath); + Path tmp = dest.resolveSibling(dest.getFileName() + ".tmp"); + Files.writeString(tmp, sb.toString()); + Files.move(tmp, dest, java.nio.file.StandardCopyOption.REPLACE_EXISTING, + java.nio.file.StandardCopyOption.ATOMIC_MOVE); + } + + private static long countLines(Path path) { + try (Stream lines = Files.lines(path)) { + return lines.count(); + } catch (IOException e) { + return 0; + } + } + + private static String escapeJson(String s) { + return s.replace("\\", "\\\\").replace("\"", "\\\""); + } + + /** + * Load timings from an existing JSON results file, returning them in + * canonical QUERY_ORDER. Returns an empty map if the file does not exist + * or cannot be parsed. + */ + private static Map> loadExistingTimings(String outputPath) { + Map> raw = new LinkedHashMap<>(); + Path p = Paths.get(outputPath); + if (!Files.exists(p)) return raw; + try { + String json = Files.readString(p); + java.util.regex.Pattern qPat = + java.util.regex.Pattern.compile("\"(q\\w+)\":\\s*\\[([^\\]]+)\\]"); + java.util.regex.Matcher m = qPat.matcher(json); + while (m.find()) { + String key = m.group(1); + List vals = new ArrayList<>(); + for (String v : m.group(2).split(",")) { + try { vals.add(Long.parseLong(v.trim())); } + catch (NumberFormatException ignored) {} + } + if (!vals.isEmpty()) raw.put(key, vals); + } + } catch (IOException e) { + System.err.println(" [warn] could not load existing timings: " + e.getMessage()); + } + // Re-order to QUERY_ORDER (LinkedHashMap preserves insertion order) + Map> ordered = new LinkedHashMap<>(); + for (String q : QUERY_ORDER) { + if (raw.containsKey(q)) ordered.put(q, raw.get(q)); + } + return ordered; + } + + /** + * Resolve a page-range style query selector to a list of query IDs. + * + * Accepted forms (case-insensitive): + * null / "" / "all" → all 18 queries in canonical order + * "3" → ["q03"] + * "2-5" → ["q02","q03","q04","q05"] + * "q02" → ["q02"] + * "q02-q05" → ["q02","q03","q04","q05"] + * "qrt" → ["qrt"] + * "q04,qrt,q07" → ["q04","qrt","q07"] + */ + private static List resolveQueryRange(String spec) { + List all = java.util.Arrays.asList(QUERY_ORDER); + if (spec == null || spec.isBlank() || spec.equalsIgnoreCase("all")) { + return all; + } + + List result = new ArrayList<>(); + for (String token : spec.split(",")) { + token = token.strip(); + if (token.contains("-")) { + String[] parts = token.split("-", 2); + int from = parseQueryIndex(parts[0].strip(), all); + int to = parseQueryIndex(parts[1].strip(), all); + if (from < 0 || to < 0) { + throw new IllegalArgumentException("Unknown query in range: " + token); + } + int lo = Math.min(from, to), hi = Math.max(from, to); + result.addAll(all.subList(lo, hi + 1)); + } else { + int idx = parseQueryIndex(token, all); + if (idx < 0) { + throw new IllegalArgumentException("Unknown query: " + token); + } + result.add(all.get(idx)); + } + } + return result; + } + + /** + * Parse a query token to its 0-based index in the canonical order. + * Accepts "q03", "qrt", or bare numbers like "3" (1-based, so "1"→q01). + * Returns -1 if not found. + */ + private static int parseQueryIndex(String token, List all) { + String lower = token.toLowerCase(java.util.Locale.ROOT); + // Direct match: "q02", "qrt" + int idx = all.indexOf(lower); + if (idx >= 0) return idx; + // Bare number: "3" → "q03" + try { + int n = Integer.parseInt(lower); + String padded = String.format("q%02d", n); + idx = all.indexOf(padded); + return idx; + } catch (NumberFormatException e) { + return -1; + } + } +} diff --git a/src/main/java/org/mobilitydb/spark/demo/BerlinMODDemo.java b/src/main/java/org/mobilitydb/spark/demo/BerlinMODDemo.java new file mode 100644 index 00000000..91ce14b5 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/demo/BerlinMODDemo.java @@ -0,0 +1,449 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.demo; + +import org.apache.spark.sql.Dataset; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.MobilitySparkSession; + +import java.util.Arrays; +import java.util.List; + +/** + * BerlinMOD Q1/Q3/Q4/Q5/Q6 — portable SQL dialect demo. + * + * Runs five BerlinMOD benchmark queries against the shared CSV dataset in + * berlinmod/data/. The SQL is identical to the MobilityDB (PostgreSQL) and + * MobilityDuck (DuckDB) versions — only named functions, no platform-specific + * operator symbols (RFC #861). + * + * Schema + * ------ + * Vehicles (vehId INT, licence STRING, type STRING, model STRING) + * Trips (tripId INT, vehId INT, trip STRING) -- trip = tgeompoint hex-WKB + * QueryLicences(licenceId INT, licence STRING) + * QueryInstants(instantId INT, instant TIMESTAMP) + * QueryPoints (pointId INT, geom STRING) -- geom = WKT text, SRID 0 + * + * Storage conventions + * ------------------- + * tgeompoint → hex-WKB STRING (temporal_as_hexwkb / temporal_from_hexwkb) + * geometry → WKT STRING (e.g. "POINT(50 0)", parsed via geo_from_text) + * + * Usage + * ----- + * spark-submit --class org.mobilitydb.spark.demo.BerlinMODDemo \ + * target/mobilityspark-*-spark.jar berlinmod/data [berlinmod/expected] + * + * argv[0]: path to berlinmod/data directory (required) + * argv[1]: path to berlinmod/expected directory — if supplied, Q1/Q4/Q5/Q6 + * results are compared against the CSV files there and the run + * exits with status 1 if any query differs. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + * JMEOS PR source: github.com/MobilityDB/JMEOS/pull/9 + */ +public final class BerlinMODDemo { + + public static void main(String[] args) { + String dataDir = args.length > 0 ? args[0] : null; + String expectDir = args.length > 1 ? args[1] : null; + + SparkSession spark = SparkSession.builder() + .master("local[2]") + .appName("MobilitySpark — BerlinMOD portable SQL") + .config("spark.sql.legacy.createHiveTableByDefault", "false") + .getOrCreate(); + spark.sparkContext().setLogLevel("WARN"); + + try (MobilitySparkSession ms = MobilitySparkSession.create(spark)) { + if (dataDir != null) { + loadFromCsv(spark, dataDir); + } else { + loadSynthetic(spark); + } + + Dataset q1 = runQ1(spark); + Dataset q2 = runQ2(spark); + Dataset q3 = runQ3(spark); + Dataset q4 = runQ4(spark); + Dataset q5 = runQ5(spark); + Dataset q6 = runQ6(spark); + Dataset q7 = runQ7(spark); + Dataset q8 = runQ8(spark); + Dataset qrt = runQRT(spark); + + if (expectDir != null) { + verify(spark, q1, q2, q3, q4, q5, q6, q7, q8, qrt, expectDir); + } + } finally { + spark.stop(); + } + } + + // ------------------------------------------------------------------ + // Data loading — from CSV files (shared with MobilityDB and MobilityDuck) + // ------------------------------------------------------------------ + + /** Package-visible entry point used by BerlinMODBench. */ + static void loadFromCsvPublic(SparkSession spark, String dataDir) { + loadFromCsv(spark, dataDir); + } + + private static void loadFromCsv(SparkSession spark, String dataDir) { + String dir = dataDir.endsWith("/") ? dataDir : dataDir + "/"; + + spark.read().option("header", "true").option("inferSchema", "true") + .csv(dir + "vehicles.csv") + .createOrReplaceTempView("Vehicles"); + + // Trips: hex-WKB strings — load directly; all UDFs call temporal_from_hexwkb. + spark.read().option("header", "true").option("inferSchema", "true") + .csv(dir + "trips.csv") + .createOrReplaceTempView("Trips"); + + spark.read().option("header", "true").option("inferSchema", "true") + .csv(dir + "query_licences.csv") + .createOrReplaceTempView("QueryLicences"); + + // QueryInstants: ensure proper TIMESTAMP type + spark.read().option("header", "true") + .csv(dir + "query_instants.csv") + .createOrReplaceTempView("QueryInstantsRaw"); + spark.sql("CREATE OR REPLACE TEMP VIEW QueryInstants AS " + + "SELECT CAST(instantid AS INT) AS instantId, " + + "CAST(instant AS TIMESTAMP) AS instant FROM QueryInstantsRaw") + .count(); + + // QueryPoints: geom column is WKT text; geomWKT is an alias used by Q11/Q12/Q15 + // for portable display (avoids geo_as_text precision divergence). + spark.read().option("header", "true") + .csv(dir + "query_points.csv") + .createOrReplaceTempView("QueryPointsRaw"); + spark.sql("CREATE OR REPLACE TEMP VIEW QueryPoints AS " + + "SELECT CAST(pointid AS INT) AS pointId, geom, geom AS geomWKT " + + "FROM QueryPointsRaw") + .count(); + + // QueryRegions: geom column stays as WKT text — eIntersects/geomContains accept WKT. + spark.read().option("header", "true") + .csv(dir + "query_regions.csv") + .createOrReplaceTempView("QueryRegionsRaw"); + spark.sql("CREATE OR REPLACE TEMP VIEW QueryRegions AS " + + "SELECT CAST(regionid AS INT) AS regionId, geom FROM QueryRegionsRaw") + .count(); + + // QueryPeriods: period column stays as STRING — atTime(trip, period) parses it. + spark.read().option("header", "true") + .csv(dir + "query_periods.csv") + .createOrReplaceTempView("QueryPeriodsRaw"); + spark.sql("CREATE OR REPLACE TEMP VIEW QueryPeriods AS " + + "SELECT CAST(periodid AS INT) AS periodId, period FROM QueryPeriodsRaw") + .count(); + } + + // ------------------------------------------------------------------ + // Data loading — synthetic in-memory data (no external files needed) + // ------------------------------------------------------------------ + private static void loadSynthetic(SparkSession spark) { + spark.sql(""" + CREATE OR REPLACE TEMP VIEW Vehicles AS SELECT * FROM VALUES + (1, 'B-AA 100', 'passenger', 'Sedan'), + (2, 'B-BB 200', 'passenger', 'SUV'), + (3, 'B-CC 300', 'truck', 'Lorry'), + (4, 'B-DD 400', 'truck', 'Truck'), + (5, 'B-EE 500', 'passenger', 'Van') + AS t(vehId, licence, type, model) + """); + + // tgeompoint WKT → hex-WKB via registered UDF + spark.sql(""" + CREATE OR REPLACE TEMP VIEW Trips AS SELECT * FROM VALUES + (1, 1, tgeompoint('[POINT(0 0)@2020-01-01 00:00:00+00, POINT(100 0)@2020-01-01 00:10:00+00]')), + (2, 2, tgeompoint('[POINT(0 5)@2020-01-01 00:00:00+00, POINT(100 5)@2020-01-01 00:10:00+00]')), + (3, 3, tgeompoint('[POINT(0 3)@2020-01-01 00:00:00+00, POINT(100 3)@2020-01-01 00:10:00+00]')), + (4, 4, tgeompoint('[POINT(0 4)@2020-01-01 00:00:00+00, POINT(100 4)@2020-01-01 00:10:00+00]')), + (5, 5, tgeompoint('[POINT(1000 1000)@2020-01-01 00:00:00+00, POINT(2000 1000)@2020-01-01 00:10:00+00]')) + AS t(tripId, vehId, trip) + """); + + spark.sql(""" + CREATE OR REPLACE TEMP VIEW QueryLicences AS SELECT * FROM VALUES + (1, 'B-AA 100'), + (2, 'B-CC 300') + AS t(licenceId, licence) + """); + + spark.sql(""" + CREATE OR REPLACE TEMP VIEW QueryInstants AS SELECT * FROM VALUES + (1, TIMESTAMP '2020-01-01 00:05:00') + AS t(instantId, instant) + """); + + // geom stored as WKT text — eIntersects accepts WKT directly (no hex-EWKB needed) + spark.sql(""" + CREATE OR REPLACE TEMP VIEW QueryPoints AS SELECT * FROM VALUES + (1, 'POINT(50 0)'), + (2, 'POINT(50 5)') + AS t(pointId, geom) + """); + + // QueryRegions: polygon covering X=40-60, Y=-1 to 6 (captures vehicles 1-4) + spark.sql(""" + CREATE OR REPLACE TEMP VIEW QueryRegions AS SELECT * FROM VALUES + (1, 'POLYGON((40 -1,60 -1,60 6,40 6,40 -1))') + AS t(regionId, geom) + """); + + // QueryPeriods: middle portion of all trips + spark.sql(""" + CREATE OR REPLACE TEMP VIEW QueryPeriods AS SELECT * FROM VALUES + (1, '[2020-01-01 00:02:00+00,2020-01-01 00:08:00+00]') + AS t(periodId, period) + """); + } + + // ------------------------------------------------------------------ + // Q1 — Models of vehicles with licences from QueryLicences. + // ------------------------------------------------------------------ + private static Dataset runQ1(SparkSession spark) { + System.out.println("=== Q1: Vehicle models for query licences ==="); + Dataset result = spark.sql(""" + SELECT l.licence, v.model + FROM QueryLicences l + JOIN Vehicles v ON v.licence = l.licence + ORDER BY l.licence + """); + result.show(); + return result; + } + + // ------------------------------------------------------------------ + // Q2 — Licence plates of vehicles that ever entered a query region. + // ------------------------------------------------------------------ + private static Dataset runQ2(SparkSession spark) { + System.out.println("=== Q2: Vehicles that ever entered a query region ==="); + Dataset result = spark.sql(""" + SELECT DISTINCT v.licence + FROM Vehicles v + JOIN Trips t ON t.vehId = v.vehId + JOIN QueryRegions r ON eIntersects(t.trip, r.geom) + ORDER BY v.licence + """); + result.show(); + return result; + } + + // ------------------------------------------------------------------ + // Q3 — Position of query-licence vehicles at each query instant. + // Binary return: pos is MEOS hex-WKB via asHexWKB() — byte-for-byte + // identical across MobilityDB, MobilityDuck, and MobilitySpark. + // ------------------------------------------------------------------ + private static Dataset runQ3(SparkSession spark) { + System.out.println("=== Q3: Vehicle positions at query instants (binary return) ==="); + Dataset result = spark.sql(""" + SELECT v.vehId AS vehid, + v.licence, + i.instantId AS instantid, + asHexWKB(atTime(t.trip, i.instant)) AS pos + FROM QueryLicences l + JOIN Vehicles v ON v.licence = l.licence + JOIN Trips t ON t.vehId = v.vehId + JOIN QueryInstants i ON true + WHERE atTime(t.trip, i.instant) IS NOT NULL + ORDER BY v.vehId, i.instantId + """); + result.show(false); + return result; + } + + // ------------------------------------------------------------------ + // Q7 — Trip portions of query-licence vehicles during each query period. + // Binary return: pos is MEOS hex-WKB via asHexWKB() — byte-for-byte + // identical across MobilityDB, MobilityDuck, and MobilitySpark. + // ------------------------------------------------------------------ + private static Dataset runQ7(SparkSession spark) { + System.out.println("=== Q7: Trip portions during query periods (binary return) ==="); + Dataset result = spark.sql(""" + SELECT v.vehId AS vehid, + v.licence, + p.periodId AS periodid, + asHexWKB(atTime(t.trip, p.period)) AS pos + FROM QueryLicences l + JOIN Vehicles v ON v.licence = l.licence + JOIN Trips t ON t.vehId = v.vehId + JOIN QueryPeriods p ON true + WHERE atTime(t.trip, p.period) IS NOT NULL + ORDER BY v.vehId, p.periodId + """); + result.show(false); + return result; + } + + // ------------------------------------------------------------------ + // Q8 — Trajectory of each vehicle as hex-WKB geometry (byte-for-byte + // identical across MobilityDB, MobilityDuck, and MobilitySpark). + // ------------------------------------------------------------------ + private static Dataset runQ8(SparkSession spark) { + System.out.println("=== Q8: Vehicle trajectories (hex WKB) ==="); + Dataset result = spark.sql(""" + SELECT tripId AS tripid, + trajectory(trip) AS traj + FROM Trips + ORDER BY tripId + """); + result.show(false); + return result; + } + + // ------------------------------------------------------------------ + // QRT — Binary roundtrip: WKT text in → MEOS hex-WKB out. + // All five trips serialised with asHexWKB(); output must be + // byte-for-byte identical across all three ecosystem platforms. + // ------------------------------------------------------------------ + private static Dataset runQRT(SparkSession spark) { + System.out.println("=== QRT: Binary roundtrip — asHexWKB(trip) for all trips ==="); + Dataset result = spark.sql(""" + SELECT tripId AS tripid, + asHexWKB(trip) AS trip_hexwkb + FROM Trips + ORDER BY tripId + """); + result.show(false); + return result; + } + + // ------------------------------------------------------------------ + // Q4 — Licence plates of vehicles that ever passed a query point. + // ------------------------------------------------------------------ + private static Dataset runQ4(SparkSession spark) { + System.out.println("=== Q4: Vehicles that ever passed a query point ==="); + Dataset result = spark.sql(""" + SELECT DISTINCT v.licence + FROM Vehicles v + JOIN Trips t ON t.vehId = v.vehId + JOIN QueryPoints p ON eIntersects(t.trip, p.geom) + ORDER BY v.licence + """); + result.show(); + return result; + } + + // ------------------------------------------------------------------ + // Q5 — Minimum nearest-approach distance between each pair of query vehicles. + // ------------------------------------------------------------------ + private static Dataset runQ5(SparkSession spark) { + System.out.println("=== Q5: Min nearest-approach distance between vehicle pairs ==="); + Dataset result = spark.sql(""" + SELECT l1.licence AS licence1, + l2.licence AS licence2, + MIN(nearestApproachDistance(t1.trip, t2.trip)) AS min_dist + FROM QueryLicences l1 + JOIN Vehicles v1 ON v1.licence = l1.licence + JOIN Trips t1 ON t1.vehId = v1.vehId + JOIN QueryLicences l2 ON l1.licenceId < l2.licenceId + JOIN Vehicles v2 ON v2.licence = l2.licence + JOIN Trips t2 ON t2.vehId = v2.vehId + WHERE nearestApproachDistance(t1.trip, t2.trip) IS NOT NULL + GROUP BY l1.licence, l2.licence + ORDER BY l1.licence, l2.licence + """); + result.show(); + return result; + } + + // ------------------------------------------------------------------ + // Q6 — Pairs of trucks that ever came within 10 m of each other. + // ------------------------------------------------------------------ + private static Dataset runQ6(SparkSession spark) { + System.out.println("=== Q6: Truck pairs within 10 m ==="); + Dataset result = spark.sql(""" + SELECT v1.licence AS licence1, + v2.licence AS licence2 + FROM Vehicles v1 + JOIN Trips t1 ON t1.vehId = v1.vehId + JOIN Vehicles v2 ON v1.vehId < v2.vehId + JOIN Trips t2 ON t2.vehId = v2.vehId + WHERE v1.type = 'truck' + AND v2.type = 'truck' + AND eDwithin(t1.trip, t2.trip, 10.0) + ORDER BY licence1, licence2 + """); + result.show(); + return result; + } + + // ------------------------------------------------------------------ + // Cross-platform verification: compare against expected CSV files. + // All queries (Q1–Q8, QRT) are compared. Q3/Q7/QRT use asHexWKB() + // for temporal types; Q8 uses geo_as_hexewkb() for geometry — all + // produce byte-for-byte identical output across all three platforms. + // ------------------------------------------------------------------ + private static void verify(SparkSession spark, + Dataset q1, Dataset q2, + Dataset q3, Dataset q4, + Dataset q5, Dataset q6, + Dataset q7, Dataset q8, + Dataset qrt, + String expectDir) { + String dir = expectDir.endsWith("/") ? expectDir : expectDir + "/"; + boolean allPass = true; + allPass &= compareQuery(spark, "Q1", q1, dir + "q01.csv"); + allPass &= compareQuery(spark, "Q2", q2, dir + "q02.csv"); + allPass &= compareQuery(spark, "Q3", q3, dir + "q03.csv"); + allPass &= compareQuery(spark, "Q4", q4, dir + "q04.csv"); + allPass &= compareQuery(spark, "Q5", q5, dir + "q05.csv"); + allPass &= compareQuery(spark, "Q6", q6, dir + "q06.csv"); + allPass &= compareQuery(spark, "Q7", q7, dir + "q07.csv"); + allPass &= compareQuery(spark, "Q8", q8, dir + "q08.csv"); + allPass &= compareQuery(spark, "QRT", qrt, dir + "qrt.csv"); + System.out.println(allPass ? "\nALL PASS" : "\nFAILURES DETECTED"); + if (!allPass) System.exit(1); + } + + private static boolean compareQuery(SparkSession spark, String name, + Dataset got, String expectedCsv) { + Dataset expected = spark.read().option("header", "true").csv(expectedCsv); + // Compare as sorted lists of column-delimited strings + List gotRows = toSortedStrings(got); + List expRows = toSortedStrings(expected); + if (gotRows.equals(expRows)) { + System.out.println("[PASS] " + name); + return true; + } + System.out.println("[FAIL] " + name); + System.out.println(" Expected: " + expRows); + System.out.println(" Got: " + gotRows); + return false; + } + + private static List toSortedStrings(Dataset ds) { + String[] rows = (String[]) ds.toJSON().collect(); + Arrays.sort(rows); + return Arrays.asList(rows); + } +} diff --git a/src/main/java/org/mobilitydb/spark/demo/BerlinMODUDFs.java b/src/main/java/org/mobilitydb/spark/demo/BerlinMODUDFs.java new file mode 100644 index 00000000..9bee1ebf --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/demo/BerlinMODUDFs.java @@ -0,0 +1,345 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.demo; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.*; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; + +/** + * BerlinMOD-specific Spark SQL UDFs that extend the base MobilitySpark surface. + * + * These UDFs cover operations needed for BerlinMOD Q09-Q16 that are not in the + * core UDF set: path length, bbox overlap (replacing &&), valueAtTimestamp, + * geo+time STBox constructors, expandSpace, tDwithin, whenTrue, aDisjoint, + * and geomContains. + * + * BerlinMODBench also preprocesses the portable SQL to rewrite Spark-incompatible + * syntax before passing to spark.sql(): + * stbox(geom, t) → geoTimeStbox(geom, t) + * expr1 && expr2 → bboxOverlaps(expr1, expr2) (per line) + * ::numeric → (removed) + * ST_Contains( → geomContains( + */ +public final class BerlinMODUDFs { + + private BerlinMODUDFs() {} + + private static final DateTimeFormatter PG_FMT = + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + /** Convert Spark java.sql.Timestamp to MEOS TimestampTz via pg_timestamptz_in. */ + private static OffsetDateTime toMeosTs(java.sql.Timestamp ts) { + String s = ts.toInstant().atOffset(ZoneOffset.UTC).format(PG_FMT); + return functions.pg_timestamptz_in(s, -1); + } + + /** Convert a String or java.sql.Timestamp to MEOS TimestampTz. */ + private static OffsetDateTime parseTs(Object arg) { + if (arg instanceof java.sql.Timestamp) return toMeosTs((java.sql.Timestamp) arg); + return functions.pg_timestamptz_in(arg.toString().trim(), -1); + } + + // ------------------------------------------------------------------ + // length(trip STRING) → DOUBLE + // Path length of a tgeompoint trajectory. + // MEOS: tpoint_length(const Temporal *) meos_geo.h:673 + // ------------------------------------------------------------------ + public static final UDF1 length = (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + return functions.tpoint_length(tptr); + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // bboxOverlaps(trip STRING, other STRING) → BOOLEAN + // Replaces the && bounding-box overlap operator in BerlinMOD SQL. + // other can be: + // - a tstzspan literal ("[2020-..., 2020-...]") → temporal overlap + // - an STBox hex-WKB string (from geoTimeStbox / expandSpace) → spatial overlap + // MEOS: overlaps_temporal_tstzspan / overlaps_tpoint_stbox (JMEOS-1.5 tpoint variant) + // ------------------------------------------------------------------ + public static final UDF2 bboxOverlaps = (trip, other) -> { + if (trip == null || other == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + char first = other.isEmpty() ? 0 : other.charAt(0); + if (first == '[' || first == '(') { + Pointer sptr = functions.tstzspan_in(other); + if (sptr == null) return null; + try { + return functions.overlaps_temporal_tstzspan(tptr, sptr); + } finally { + MeosMemory.free(sptr); + } + } else { + Pointer bptr = functions.stbox_from_hexwkb(other); + if (bptr == null) return null; + try { + return functions.overlaps_tspatial_stbox(tptr, bptr); + } finally { + MeosMemory.free(bptr); + } + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // valueAtTimestamp(trip STRING, instant) → STRING (WKT geometry) + // Returns the geometry of a tgeompoint at a given instant, as WKT. + // instant can be a java.sql.Timestamp (Spark TIMESTAMP) or String. + // MEOS: temporal_value_at_timestamptz (MEOS 1.4 canonical name) + // ------------------------------------------------------------------ + public static final UDF2 valueAtTimestamp = (trip, tsArg) -> { + if (trip == null || tsArg == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + OffsetDateTime odt = parseTs(tsArg); + if (odt == null) return null; + Pointer valueOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + boolean found = functions.temporal_value_at_timestamptz(tptr, odt, true, valueOut); + if (!found) return null; + long addr = valueOut.getLong(0); + if (addr == 0L) return null; + Pointer geomPtr = Runtime.getSystemRuntime().getMemoryManager().newPointer(addr); + return functions.geo_as_text(geomPtr, 15); + }; + + // ------------------------------------------------------------------ + // geoTimeStbox(geomWkt STRING, instant_or_period) → STRING (STBox hex-WKB) + // Replaces stbox(geom, instant) and stbox(geom, period) in BerlinMOD SQL. + // Second arg: java.sql.Timestamp → geo_timestamptz_to_stbox + // String "[...]" → geo_tstzspan_to_stbox + // String "..." → treat as timestamp string + // MEOS: geo_timestamptz_to_stbox / geo_tstzspan_to_stbox meos_geo.h:506-507 + // ------------------------------------------------------------------ + public static final UDF2 geoTimeStbox = (geomWkt, tsArg) -> { + if (geomWkt == null || tsArg == null) return null; + MeosThread.ensureReady(); + Pointer gptr = functions.geo_from_text(geomWkt, 0); + if (gptr == null) return null; + try { + Pointer result; + if (tsArg instanceof java.sql.Timestamp) { + OffsetDateTime odt = toMeosTs((java.sql.Timestamp) tsArg); + if (odt == null) return null; + result = functions.geo_timestamptz_to_stbox(gptr, odt); + } else { + String s = tsArg.toString().trim(); + if (s.isEmpty()) return null; + if (s.charAt(0) == '[' || s.charAt(0) == '(') { + Pointer sptr = functions.tstzspan_in(s); + if (sptr == null) return null; + try { + result = functions.geo_tstzspan_to_stbox(gptr, sptr); + } finally { + MeosMemory.free(sptr); + } + } else { + OffsetDateTime odt = functions.pg_timestamptz_in(s, -1); + if (odt == null) return null; + result = functions.geo_timestamptz_to_stbox(gptr, odt); + } + } + if (result == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(result, (byte) 0, sizeOut); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(gptr); + } + }; + + // ------------------------------------------------------------------ + // expandSpace(trip STRING, dist NUMBER) → STRING (STBox hex-WKB) + // Computes the STBox of a trip then expands it spatially by dist. + // Used in Q10 as a bounding-box pre-filter: bboxOverlaps(trip, expandSpace(...)). + // MEOS: tspatial_to_stbox + stbox_expand_space meos_geo.h:548 + // ------------------------------------------------------------------ + public static final UDF2 expandSpace = (trip, dist) -> { + if (trip == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + if (bbox == null) return null; + try { + Pointer expanded = functions.stbox_expand_space(bbox, dist.doubleValue()); + if (expanded == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(expanded, (byte) 0, sizeOut); + } finally { + MeosMemory.free(expanded); + } + } finally { + MeosMemory.free(bbox); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tDwithin(t1 STRING, t2 STRING, dist NUMBER) → STRING (tbool hex-WKB) + // Returns a temporal boolean showing when the two trajectories are within + // dist of each other (used by Q10 with whenTrue). + // MEOS: tdwithin_tpoint_tpoint (JMEOS-1.5 tpoint variant) + // Note: JMEOS wraps with extra (restr, atvalue) booleans; pass false,false + // to get the full temporal result. + // ------------------------------------------------------------------ + public static final UDF3 tDwithin = (t1, t2, dist) -> { + if (t1 == null || t2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(t1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(t2); + if (p2 == null) return null; + try { + Pointer result = functions.tdwithin_tgeo_tgeo(p1, p2, dist.doubleValue()); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // whenTrue(tbool STRING) → STRING (tstzspanset text) + // ------------------------------------------------------------------ + public static final UDF1 whenTrue = (tbool) -> { + if (tbool == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(tbool); + if (tptr == null) return null; + try { + Pointer sset = functions.tbool_when_true(tptr); + if (sset == null) return null; + try { + return functions.tstzspanset_out(sset); + } finally { + MeosMemory.free(sset); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // aDisjoint(t1 STRING, t2 STRING) → BOOLEAN + // ------------------------------------------------------------------ + public static final UDF2 aDisjoint = (t1, t2) -> { + if (t1 == null || t2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(t1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(t2); + if (p2 == null) return null; + try { + return functions.adisjoint_tgeo_tgeo(p1, p2) == 1; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // geomContains(outer STRING, inner STRING) → BOOLEAN + // Replaces ST_Contains in Q14. Approximated via econtains_geo_tgeo. + // ------------------------------------------------------------------ + public static final UDF2 geomContains = (outer, inner) -> { + if (outer == null || inner == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(outer, 0); + if (g1 == null) return null; + try { + OffsetDateTime epoch = functions.pg_timestamptz_in("2000-01-01", -1); + Pointer innerGeo = functions.geo_from_text(inner, 0); + if (innerGeo == null) return null; + try { + Pointer tptr = functions.tpointinst_make(innerGeo, epoch); + if (tptr == null) return null; + try { + return functions.econtains_geo_tgeo(g1, tptr) == 1; + } finally { + MeosMemory.free(tptr); + } + } finally { + MeosMemory.free(innerGeo); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("length", length, DataTypes.DoubleType); + spark.udf().register("bboxOverlaps", bboxOverlaps, DataTypes.BooleanType); + spark.udf().register("valueAtTimestamp", valueAtTimestamp, DataTypes.StringType); + spark.udf().register("geoTimeStbox", geoTimeStbox, DataTypes.StringType); + spark.udf().register("expandSpace", expandSpace, DataTypes.StringType); + spark.udf().register("tDwithin", tDwithin, DataTypes.StringType); + spark.udf().register("whenTrue", whenTrue, DataTypes.StringType); + spark.udf().register("aDisjoint", aDisjoint, DataTypes.BooleanType); + spark.udf().register("geomContains", geomContains, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/examples/N01HelloWorld.java b/src/main/java/org/mobilitydb/spark/examples/N01HelloWorld.java new file mode 100644 index 00000000..90664694 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/examples/N01HelloWorld.java @@ -0,0 +1,70 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.examples; + +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.MobilitySparkSession; + +import static functions.functions.*; + +/** + * N01 Hello World — the minimal MobilitySpark program. + * + * Creates a single tgeompoint value inside Spark SQL, rounds it back to + * text, and prints it. Mirrors meos/examples/01_hello_world.c. + * + * Run with: + * spark-submit --class org.mobilitydb.spark.examples.N01HelloWorld \ + * target/mobilityspark-0.1.0-SNAPSHOT-spark.jar + */ +public final class N01HelloWorld { + + public static void main(String[] args) { + SparkSession spark = SparkSession.builder() + .master("local[2]") + .appName("MobilitySpark N01 Hello World") + .getOrCreate(); + spark.sparkContext().setLogLevel("WARN"); + + try (MobilitySparkSession ms = MobilitySparkSession.create(spark)) { + + // Build a tgeompoint sequence and round-trip through hex-WKB. + String wkt = "[POINT(1 1)@2020-01-01 00:00:00+00, " + + "POINT(2 2)@2020-01-01 01:00:00+00]"; + String hex = temporal_as_hexwkb(tgeompoint_in(wkt), (byte) 0); + + // Register a simple view so we can use Spark SQL. + spark.sql("CREATE OR REPLACE TEMPORARY VIEW trips AS " + + "SELECT '" + hex + "' AS trip"); + + System.out.println("=== Hello World: tgeompoint round-trip ==="); + spark.sql("SELECT trip FROM trips").show(false); + + } finally { + spark.stop(); + } + } +} diff --git a/src/main/java/org/mobilitydb/spark/examples/N03BerlinMOD.java b/src/main/java/org/mobilitydb/spark/examples/N03BerlinMOD.java new file mode 100644 index 00000000..c567df37 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/examples/N03BerlinMOD.java @@ -0,0 +1,48 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.examples; + +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.MobilitySparkSession; +import org.mobilitydb.spark.demo.BerlinMODDemo; + +/** + * N03 BerlinMOD — portable SQL benchmark queries Q1/Q3/Q4/Q5/Q6. + * + * Delegates to {@link BerlinMODDemo} which runs the five BerlinMOD queries + * in the portable named-function SQL dialect (identical to MobilityDB and + * MobilityDuck). Mirrors meos/examples/03_berlinmod_assemble.c. + * + * Run with: + * spark-submit --class org.mobilitydb.spark.examples.N03BerlinMOD \ + * target/mobilityspark-0.1.0-SNAPSHOT-spark.jar + */ +public final class N03BerlinMOD { + + public static void main(String[] args) { + BerlinMODDemo.main(args); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/AlwaysSpatialRelsUDFs.java b/src/main/java/org/mobilitydb/spark/geo/AlwaysSpatialRelsUDFs.java new file mode 100644 index 00000000..44740fd7 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/AlwaysSpatialRelsUDFs.java @@ -0,0 +1,151 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for "always" spatial relationship predicates: do all + * times in the temporal value satisfy the relation? Counterpart to the + * "ever" family in TempSpatialRelsUDFs. + * + * MEOS function authority: meos/include/meos_geo.h + * + * Native functions return int (-1 = error, 0 = false, 1 = true). The + * UDF wrappers convert to Boolean (null on error). + */ +public final class AlwaysSpatialRelsUDFs { + + private AlwaysSpatialRelsUDFs() {} + + @FunctionalInterface + private interface IntBiFn { int apply(Pointer a, Pointer b); } + + @FunctionalInterface + private interface IntTriFn { int apply(Pointer a, Pointer b, double dist); } + + private static Boolean tri(int v) { + return v == -1 ? null : v == 1; + } + + private static UDF2 tgeoGeo(IntBiFn fn) { + return (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); if (t == null) return null; + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) { MeosMemory.free(t); return null; } + try { return tri(fn.apply(t, g)); } + finally { MeosMemory.free(t, g); } + }; + } + + private static UDF2 tgeoTgeo(IntBiFn fn) { + return (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return tri(fn.apply(p1, p2)); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 geoTgeo(IntBiFn fn) { + return (geomWkt, trip) -> { + if (geomWkt == null || trip == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(geomWkt, 0); if (g == null) return null; + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) { MeosMemory.free(g); return null; } + try { return tri(fn.apply(g, t)); } + finally { MeosMemory.free(g, t); } + }; + } + + private static UDF3 tgeoGeoDist(IntTriFn fn) { + return (trip, geomWkt, dist) -> { + if (trip == null || geomWkt == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); if (t == null) return null; + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) { MeosMemory.free(t); return null; } + try { return tri(fn.apply(t, g, dist)); } + finally { MeosMemory.free(t, g); } + }; + } + + private static UDF3 tgeoTgeoDist(IntTriFn fn) { + return (trip1, trip2, dist) -> { + if (trip1 == null || trip2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return tri(fn.apply(p1, p2, dist)); } + finally { MeosMemory.free(p1, p2); } + }; + } + + public static final UDF2 aDisjointTgeoGeo = tgeoGeo(functions::adisjoint_tgeo_geo); + public static final UDF2 aDisjointTgeoTgeo = tgeoTgeo(functions::adisjoint_tgeo_tgeo); + public static final UDF2 aIntersectsTgeoGeo = tgeoGeo(functions::aintersects_tgeo_geo); + public static final UDF2 aIntersectsTgeoTgeo = tgeoTgeo(functions::aintersects_tgeo_tgeo); + public static final UDF2 aTouchesTgeoGeo = tgeoGeo(functions::atouches_tgeo_geo); + public static final UDF2 aTouchesTgeoTgeo = tgeoTgeo(functions::atouches_tgeo_tgeo); + public static final UDF2 aContainsTgeoGeo = tgeoGeo(functions::acontains_tgeo_geo); + public static final UDF2 aContainsTgeoTgeo = tgeoTgeo(functions::acontains_tgeo_tgeo); + public static final UDF2 aContainsGeoTgeo = geoTgeo(functions::acontains_geo_tpoint); + public static final UDF2 aCoversTgeoGeo = tgeoGeo(functions::acovers_tgeo_geo); + + public static final UDF3 aDwithinTgeoGeo = tgeoGeoDist(functions::adwithin_tgeo_geo); + public static final UDF3 aDwithinTgeoTgeo = tgeoTgeoDist(functions::adwithin_tgeo_tgeo); + + public static void registerAll(SparkSession spark) { + spark.udf().register("aDisjointTgeoGeo", aDisjointTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aDisjointTgeoTgeo", aDisjointTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("aIntersectsTgeoGeo", aIntersectsTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aIntersectsTgeoTgeo", aIntersectsTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("aTouchesTgeoGeo", aTouchesTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aTouchesTgeoTgeo", aTouchesTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("aContainsTgeoGeo", aContainsTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aContainsTgeoTgeo", aContainsTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("aContainsGeoTgeo", aContainsGeoTgeo, DataTypes.BooleanType); + spark.udf().register("aCoversTgeoGeo", aCoversTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aDwithinTgeoGeo", aDwithinTgeoGeo, DataTypes.BooleanType); + spark.udf().register("aDwithinTgeoTgeo", aDwithinTgeoTgeo, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/DistanceUDFs.java b/src/main/java/org/mobilitydb/spark/geo/DistanceUDFs.java new file mode 100644 index 00000000..76d2da33 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/DistanceUDFs.java @@ -0,0 +1,427 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosNative; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for temporal distance operations between tgeo/tnumber types. + * + * All functions return a hex-WKB tfloat (the distance evolving over time). + * Input geometry is accepted as WKT strings. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +public final class DistanceUDFs { + + private DistanceUDFs() {} + + // ------------------------------------------------------------------ + // Spatial distance — tgeo × geometry + // ------------------------------------------------------------------ + + // tdistanceTgeoGeo(trip STRING, geomWkt STRING) → STRING (tfloat hex-WKB) + // MEOS: tdistance_tgeo_geo(const Temporal *, const GSERIALIZED *) → Temporal * + public static final UDF2 tdistanceTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) { MeosMemory.free(tptr); return null; } + try { + Pointer r = functions.tdistance_tgeo_geo(tptr, gsptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + MeosMemory.free(gsptr); + } + }; + + // ------------------------------------------------------------------ + // Spatial distance — tgeo × tgeo + // ------------------------------------------------------------------ + + // tdistanceTgeoTgeo(trip1 STRING, trip2 STRING) → STRING (tfloat hex-WKB) + // MEOS: tdistance_tgeo_tgeo(const Temporal *, const Temporal *) → Temporal * + public static final UDF2 tdistanceTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = functions.tdistance_tgeo_tgeo(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + // ------------------------------------------------------------------ + // Number distance — tfloat × float + // ------------------------------------------------------------------ + + // tdistanceTfloatFloat(tfloat STRING, d DOUBLE) → STRING (tfloat hex-WKB) + // MEOS: tdistance_tfloat_float(const Temporal *, double) → Temporal * + public static final UDF2 tdistanceTfloatFloat = + (hex, d) -> { + if (hex == null || d == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer r = functions.tdistance_tfloat_float(ptr, d); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Number distance — tint × int + // ------------------------------------------------------------------ + + // tdistanceTintInt(tint STRING, i INT) → STRING (tint hex-WKB) + // MEOS: tdistance_tint_int(const Temporal *, int) → Temporal * + public static final UDF2 tdistanceTintInt = + (hex, i) -> { + if (hex == null || i == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer r = functions.tdistance_tint_int(ptr, i); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Number distance — tnumber × tnumber + // ------------------------------------------------------------------ + + // tdistanceTnumberTnumber(t1 STRING, t2 STRING) → STRING (tfloat hex-WKB) + // MEOS: tdistance_tnumber_tnumber(const Temporal *, const Temporal *) → Temporal * + public static final UDF2 tdistanceTnumberTnumber = + (hex1, hex2) -> { + if (hex1 == null || hex2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(hex1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(hex2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = functions.tdistance_tnumber_tnumber(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + // ------------------------------------------------------------------ + // Nearest approach distance (NAD) — returns Double (null on failure) + // MEOS returns DBL_MAX when the inputs never approach; map to null. + // ------------------------------------------------------------------ + + // nadTgeoGeo(trip STRING, geomWkt STRING) → DOUBLE + // MEOS: nad_tgeo_geo(const Temporal *, const GSERIALIZED *) → double + public static final UDF2 nadTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) { MeosMemory.free(tptr); return null; } + try { + double d = MeosNative.INSTANCE.nad_tgeo_geo(tptr, gsptr); + return d == Double.MAX_VALUE ? null : d; + } finally { + MeosMemory.free(tptr); + MeosMemory.free(gsptr); + } + }; + + // nadTgeoStbox(trip STRING, stboxHex STRING) → DOUBLE + // MEOS: nad_tgeo_stbox(const Temporal *, const STBox *) → double + public static final UDF2 nadTgeoStbox = + (trip, stboxHex) -> { + if (trip == null || stboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer sptr = functions.stbox_from_hexwkb(stboxHex); + if (sptr == null) { MeosMemory.free(tptr); return null; } + try { + double d = MeosNative.INSTANCE.nad_tgeo_stbox(tptr, sptr); + return d == Double.MAX_VALUE ? null : d; + } finally { + MeosMemory.free(tptr); + MeosMemory.free(sptr); + } + }; + + // nadTgeoTgeo(trip1 STRING, trip2 STRING) → DOUBLE + // MEOS: nad_tgeo_tgeo(const Temporal *, const Temporal *) → double + public static final UDF2 nadTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + double d = MeosNative.INSTANCE.nad_tgeo_tgeo(p1, p2); + return d == Double.MAX_VALUE ? null : d; + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + // ------------------------------------------------------------------ + // Nearest approach instant (NAI) — returns hex-WKB TInstant (STRING) + // ------------------------------------------------------------------ + + // naiTgeoGeo(trip STRING, geomWkt STRING) → STRING (TInstant hex-WKB) + // MEOS: nai_tgeo_geo(const Temporal *, const GSERIALIZED *) → TInstant * + public static final UDF2 naiTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) { MeosMemory.free(tptr); return null; } + try { + Pointer r = MeosNative.INSTANCE.nai_tgeo_geo(tptr, gsptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + MeosMemory.free(gsptr); + } + }; + + // ------------------------------------------------------------------ + // Shortest line — returns geometry (WKT) of the closest-approach segment + // ------------------------------------------------------------------ + + // shortestLineTgeoGeo(trip STRING, geomWkt STRING) → STRING (WKT geometry) + // MEOS: shortestline_tgeo_geo(const Temporal *, const GSERIALIZED *) → GSERIALIZED * + public static final UDF2 shortestLineTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) { MeosMemory.free(tptr); return null; } + try { + Pointer r = MeosNative.INSTANCE.shortestline_tgeo_geo(tptr, gsptr); + if (r == null) return null; + try { + return functions.geo_as_text(r, 6); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + MeosMemory.free(gsptr); + } + }; + + // shortestLineTgeoTgeo(trip1 STRING, trip2 STRING) → STRING (WKT geometry) + // MEOS: shortestline_tgeo_tgeo(const Temporal *, const Temporal *) → GSERIALIZED * + public static final UDF2 shortestLineTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = functions.shortestline_tgeo_tgeo(p1, p2); + if (r == null) return null; + try { + return functions.geo_as_text(r, 6); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + // naiTgeoTgeo(trip1 STRING, trip2 STRING) → STRING (TInstant hex-WKB) + // MEOS: nai_tgeo_tgeo(const Temporal *, const Temporal *) → TInstant * + public static final UDF2 naiTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = MeosNative.INSTANCE.nai_tgeo_tgeo(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + // ------------------------------------------------------------------ + // Minimum spatial distance (MobilityDB PR #1007) + // minDistance({tgeo,geo},{tgeo,geo}) → double + // Per-pair scalar. For the GROUP-BY-over-cross-join shape that the + // canonical Q5 expresses, wrap with the built-in MIN aggregate: + // + // SELECT MIN(minDistance(t1.trip, t2.trip)) FROM ... GROUP BY ... + // + // The (tgeo, geo) overload reuses the NAD kernel — NAD reduces to + // spatial-min when one argument has no time dimension. The (tgeo, + // tgeo) overload calls the threshold-aware kernel with DBL_MAX so + // every call computes the exact per-pair minimum; the kernel still + // benefits from the outer STBox lower-bound prune. + // ------------------------------------------------------------------ + + // minDistance(trip STRING, geomWkt STRING) → DOUBLE + public static final UDF2 minDistanceTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) { MeosMemory.free(tptr); return null; } + try { + double d = MeosNative.INSTANCE.nad_tgeo_geo(tptr, gsptr); + return d == Double.MAX_VALUE ? null : d; + } finally { + MeosMemory.free(tptr); + MeosMemory.free(gsptr); + } + }; + + // minDistance(trip1 STRING, trip2 STRING) → DOUBLE + public static final UDF2 minDistanceTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + double d = MeosNative.INSTANCE.mindistance_tgeo_tgeo( + p1, p2, Double.MAX_VALUE); + return d == Double.MAX_VALUE ? null : d; + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("tdistanceTgeoGeo", tdistanceTgeoGeo, DataTypes.StringType); + spark.udf().register("tdistanceTgeoTgeo", tdistanceTgeoTgeo, DataTypes.StringType); + spark.udf().register("tdistanceTfloatFloat", tdistanceTfloatFloat, DataTypes.StringType); + spark.udf().register("tdistanceTintInt", tdistanceTintInt, DataTypes.StringType); + spark.udf().register("tdistanceTnumberTnumber", tdistanceTnumberTnumber, DataTypes.StringType); + + spark.udf().register("nadTgeoGeo", nadTgeoGeo, DataTypes.DoubleType); + spark.udf().register("nadTgeoStbox", nadTgeoStbox, DataTypes.DoubleType); + spark.udf().register("nadTgeoTgeo", nadTgeoTgeo, DataTypes.DoubleType); + spark.udf().register("naiTgeoGeo", naiTgeoGeo, DataTypes.StringType); + spark.udf().register("naiTgeoTgeo", naiTgeoTgeo, DataTypes.StringType); + spark.udf().register("shortestLineTgeoGeo", shortestLineTgeoGeo, DataTypes.StringType); + spark.udf().register("shortestLineTgeoTgeo", shortestLineTgeoTgeo, DataTypes.StringType); + + spark.udf().register("minDistanceTgeoGeo", minDistanceTgeoGeo, DataTypes.DoubleType); + spark.udf().register("minDistanceTgeoTgeo", minDistanceTgeoTgeo, DataTypes.DoubleType); + + // MobilityDB SQL bare-name aliases. + // The portable operator alias `nearestApproachDistance` (|=|) is + // registered by org.mobilitydb.spark.portable.PortableOperatorAliasUDFs, + // reusing this same nadTgeoGeo backing field. + spark.udf().register("nearestApproachInstant", naiTgeoGeo, DataTypes.StringType); + spark.udf().register("shortestLine", shortestLineTgeoGeo, DataTypes.StringType); + spark.udf().register("minDistance", minDistanceTgeoTgeo, DataTypes.DoubleType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/GeoAffineUDFs.java b/src/main/java/org/mobilitydb/spark/geo/GeoAffineUDFs.java new file mode 100644 index 00000000..4b408c8c --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/GeoAffineUDFs.java @@ -0,0 +1,176 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosNative; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.api.java.UDF4; +import org.apache.spark.sql.api.java.UDF5; +import org.apache.spark.sql.api.java.UDF13; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for affine transformations on tgeo: translate, rotate + * (2D), rotateX/Y/Z (3D), transscale. + * + * MobilityDB SQL composes these from MEOS's single tgeo_affine(Temporal*, + * AFFINE*) primitive. We build the AFFINE struct in direct memory and call + * tgeo_affine via MeosNative. + * + * AFFINE layout (96 bytes, all doubles): + * afac bfac cfac — row 0 spatial coefficients + * dfac efac ffac — row 1 + * gfac hfac ifac — row 2 + * xoff yoff zoff — translation offsets + * + * Identity matrix: afac=efac=ifac=1, all other coefficients 0. + */ +public final class GeoAffineUDFs { + + private GeoAffineUDFs() {} + + private static Pointer makeAffine(double afac, double bfac, double cfac, + double dfac, double efac, double ffac, + double gfac, double hfac, double ifac, + double xoff, double yoff, double zoff) { + Pointer aff = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(96); + aff.putDouble(0, afac); + aff.putDouble(8, bfac); + aff.putDouble(16, cfac); + aff.putDouble(24, dfac); + aff.putDouble(32, efac); + aff.putDouble(40, ffac); + aff.putDouble(48, gfac); + aff.putDouble(56, hfac); + aff.putDouble(64, ifac); + aff.putDouble(72, xoff); + aff.putDouble(80, yoff); + aff.putDouble(88, zoff); + return aff; + } + + private static String applyAffine(String hex, Pointer affine) { + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + Pointer r = MeosNative.INSTANCE.tgeo_affine(t, affine); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(t); } + } + + // translate(temporal, dx, dy) — 2D translation (z unchanged) + public static final UDF3 translate2 = + (hex, dx, dy) -> { + if (hex == null || dx == null || dy == null) return null; + MeosThread.ensureReady(); + return applyAffine(hex, makeAffine(1,0,0, 0,1,0, 0,0,1, dx, dy, 0)); + }; + + // translate(temporal, dx, dy, dz) — 3D translation + public static final UDF4 translate3 = + (hex, dx, dy, dz) -> { + if (hex == null || dx == null || dy == null || dz == null) return null; + MeosThread.ensureReady(); + return applyAffine(hex, makeAffine(1,0,0, 0,1,0, 0,0,1, dx, dy, dz)); + }; + + // rotate(temporal, angleRadians) — 2D rotation around origin (z unchanged) + public static final UDF2 rotate = + (hex, angle) -> { + if (hex == null || angle == null) return null; + MeosThread.ensureReady(); + double c = Math.cos(angle), s = Math.sin(angle); + return applyAffine(hex, makeAffine(c,-s,0, s,c,0, 0,0,1, 0, 0, 0)); + }; + + // rotateX(temporal, angleRadians) — 3D rotation about x-axis + public static final UDF2 rotateX = + (hex, angle) -> { + if (hex == null || angle == null) return null; + MeosThread.ensureReady(); + double c = Math.cos(angle), s = Math.sin(angle); + return applyAffine(hex, makeAffine(1,0,0, 0,c,-s, 0,s,c, 0, 0, 0)); + }; + + // rotateY(temporal, angleRadians) — 3D rotation about y-axis + public static final UDF2 rotateY = + (hex, angle) -> { + if (hex == null || angle == null) return null; + MeosThread.ensureReady(); + double c = Math.cos(angle), s = Math.sin(angle); + return applyAffine(hex, makeAffine(c,0,s, 0,1,0, -s,0,c, 0, 0, 0)); + }; + + // rotateZ(temporal, angleRadians) — 3D rotation about z-axis + public static final UDF2 rotateZ = + (hex, angle) -> { + if (hex == null || angle == null) return null; + MeosThread.ensureReady(); + double c = Math.cos(angle), s = Math.sin(angle); + return applyAffine(hex, makeAffine(c,-s,0, s,c,0, 0,0,1, 0, 0, 0)); + }; + + // transscale(temporal, dx, dy, sx, sy) — translate then scale + // Equivalent affine: ((px+dx)*sx, (py+dy)*sy) = sx*px + sx*dx, sy*py + sy*dy + public static final UDF5 transscale = + (hex, dx, dy, sx, sy) -> { + if (hex == null || dx == null || dy == null || sx == null || sy == null) return null; + MeosThread.ensureReady(); + return applyAffine(hex, makeAffine(sx,0,0, 0,sy,0, 0,0,1, sx*dx, sy*dy, 0)); + }; + + // affine(temporal, afac, bfac, cfac, dfac, efac, ffac, gfac, hfac, ifac, xoff, yoff, zoff) + public static final UDF13 affine = + (hex, afac, bfac, cfac, dfac, efac, ffac, gfac, hfac, ifac, xoff, yoff, zoff) -> { + if (hex == null || afac == null || bfac == null || cfac == null || dfac == null + || efac == null || ffac == null || gfac == null || hfac == null || ifac == null + || xoff == null || yoff == null || zoff == null) return null; + MeosThread.ensureReady(); + return applyAffine(hex, makeAffine(afac, bfac, cfac, dfac, efac, ffac, + gfac, hfac, ifac, xoff, yoff, zoff)); + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("translate", translate2, DataTypes.StringType); + spark.udf().register("translate3", translate3, DataTypes.StringType); + spark.udf().register("rotate", rotate, DataTypes.StringType); + spark.udf().register("rotateX", rotateX, DataTypes.StringType); + spark.udf().register("rotateY", rotateY, DataTypes.StringType); + spark.udf().register("rotateZ", rotateZ, DataTypes.StringType); + spark.udf().register("transscale", transscale, DataTypes.StringType); + spark.udf().register("affine", affine, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFs.java b/src/main/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFs.java new file mode 100644 index 00000000..e97af0e4 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFs.java @@ -0,0 +1,494 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.*; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +/** + * Spark SQL UDFs for high-value spatial analytics on temporal geometry types. + * + * Coverage: + * - Plain geometry operations: geomBuffer, geomConvexHull, geomIntersection + * - SRID / CRS management: setSRID, transform + * - Text output: asText, asEWKT + * - Elevation restriction: atElevation (3-D trips) + * - Temporal spatial predicates (TBool): tContains, tCovers, tDwithin + * - Bearing analytics: bearingToPoint, bearing + * - Spatial aggregates: twCentroid + * + * Storage convention: + * tgeompoint → hex-WKB STRING (temporal_as_hexwkb) + * geometry → WKT STRING (parsed via geo_from_text) + * TBool result → hex-WKB STRING + * TFloat result → hex-WKB STRING + * + * MEOS function authority: meos/include/meos_geo.h + */ +public final class GeoAnalyticsUDFs { + + private GeoAnalyticsUDFs() {} + + // Convenience: decode a trip and extract its SRID from its bounding box + private static int tripSrid(Pointer tptr) { + Pointer bbox = functions.tspatial_to_stbox(tptr); + return (bbox != null) ? functions.stbox_srid(bbox) : 0; + } + + // ------------------------------------------------------------------ + // GEOMETRY OPERATIONS (plain geometry in/out, WKT strings) + // + // MEOS: geom_buffer(gs, size, params) meos_geo.h:401 + // geom_convex_hull(gs) meos_geo.h:403 + // geom_intersection2d(gs1, gs2) meos_geo.h:405 + // ------------------------------------------------------------------ + + // geomBuffer("POLYGON((...))", 100.0) → WKT of buffered polygon + public static final UDF2 geomBuffer = + (geomWkt, radius) -> { + if (geomWkt == null || radius == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) return null; + Pointer r = functions.geom_buffer(g, radius, ""); + if (r == null) return null; + return functions.geo_as_text(r, 15); + }; + + // geomConvexHull("MULTIPOINT((0 0),(1 1),(0 1))") → "POLYGON((0 0,0 1,1 1,0 0))" + public static final UDF1 geomConvexHull = + (geomWkt) -> { + if (geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) return null; + Pointer r = functions.geom_convex_hull(g); + if (r == null) return null; + return functions.geo_as_text(r, 15); + }; + + // geomIntersection("POLYGON(...)", "POLYGON(...)") → WKT of intersection + public static final UDF2 geomIntersection = + (geomWkt1, geomWkt2) -> { + if (geomWkt1 == null || geomWkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(geomWkt1, 0); + Pointer g2 = functions.geo_from_text(geomWkt2, 0); + if (g1 == null || g2 == null) return null; + Pointer r = functions.geom_intersection2d(g1, g2); + if (r == null) return null; + return functions.geo_as_text(r, 15); + }; + + // ------------------------------------------------------------------ + // SRID / CRS MANAGEMENT (temporal in/out, hex-WKB strings) + // + // MEOS: tspatial_set_srid(temp, srid) meos_geo.h:687 + // tspatial_transform(temp, srid) meos_geo.h:688 + // ------------------------------------------------------------------ + + // setSRID(trip, 4326) → same trip with SRID label changed (no reprojection) + public static final UDF2 setSRID = + (trip, srid) -> { + if (trip == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer r = functions.tspatial_set_srid(tptr, srid); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // transform(trip, 4326) → trip reprojected to SRID 4326 + public static final UDF2 transform = + (trip, srid) -> { + if (trip == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer r = functions.tspatial_transform(tptr, srid); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // TEXT OUTPUT (temporal in, WKT/EWKT string out) + // + // MEOS: tspatial_as_text(temp, maxdd) meos_geo.h:620 + // tspatial_as_ewkt(temp, maxdd) meos_geo.h:619 + // ------------------------------------------------------------------ + + // asText(trip, 6) → "[POINT(1.234567 2.345678)@2020-01-01, ...]" + public static final UDF2 asText = + (trip, maxdd) -> { + if (trip == null || maxdd == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + return functions.tspatial_as_text(tptr, maxdd); + }; + + // asEWKT(trip, 6) → "[SRID=4326;POINT(...)@2020-01-01, ...]" + public static final UDF2 asEWKT = + (trip, maxdd) -> { + if (trip == null || maxdd == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + return functions.tspatial_as_ewkt(tptr, maxdd); + }; + + // ------------------------------------------------------------------ + // ELEVATION RESTRICTION (3-D tgeompoint, hex-WKB out) + // + // MEOS: tpoint_at_elevation(temp, zspan) meos_geo.h:699 + // floatspan_make(lower, upper, lower_inc, upper_inc) + // + // zmin/zmax define the closed [zmin, zmax] elevation band. + // Returns null when no portion of the trip falls in the band. + // ------------------------------------------------------------------ + + // atElevation(trip, 0.0, 100.0) → sub-trip within elevation band [0,100] + public static final UDF3 atElevation = + (trip, zmin, zmax) -> { + if (trip == null || zmin == null || zmax == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer zspan = functions.floatspan_make(zmin, zmax, true, true); + if (zspan == null) return null; + Pointer r = functions.tpoint_at_elevation(tptr, zspan); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // TEMPORAL SPATIAL PREDICATES (TBool hex-WKB out) + // + // MEOS: tcontains_geo_tgeo(gs, temp) meos_geo.h:837 + // tcovers_tgeo_tgeo(temp1, temp2) meos_geo.h:842 + // tdwithin_tgeo_tgeo(temp1, temp2, dist) meos_geo.h:848 + // + // These return temporal booleans: at each instant, whether the + // predicate holds. Result is encoded as hex-WKB for downstream UDFs. + // ------------------------------------------------------------------ + + // tContains("POLYGON(...)", trip) → tbool hex-WKB: true at instants inside polygon + public static final UDF2 tContains = + (geomWkt, trip) -> { + if (geomWkt == null || trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + int srid = tripSrid(tptr); + Pointer g = functions.geo_from_text(geomWkt, srid); + if (g == null) return null; + Pointer r = functions.tcontains_geo_tgeo(g, tptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // tCovers(trip1, trip2) → tbool hex-WKB: true at instants where trip1 covers trip2 + public static final UDF2 tCovers = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.tcovers_tgeo_tgeo(p1, p2); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // tDwithin(trip1, trip2, 100.0) → tbool hex-WKB: true at instants within 100 units + public static final UDF3 tDwithin = + (trip1, trip2, dist) -> { + if (trip1 == null || trip2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.tdwithin_tgeo_tgeo(p1, p2, dist.doubleValue()); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // BEARING ANALYTICS (TFloat hex-WKB out) + // + // MEOS: bearing_tpoint_point(temp, gs, invert) meos_geo.h + // bearing_tpoint_tpoint(temp1, temp2) meos_geo.h + // + // bearing_tpoint_point: invert=false → bearing FROM trip TO point. + // ------------------------------------------------------------------ + + // bearingToPoint(trip, "POINT(lon lat)") → tfloat hex-WKB, bearing in radians + public static final UDF2 bearingToPoint = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + int srid = tripSrid(tptr); + Pointer g = functions.geo_from_text(geomWkt, srid); + if (g == null) return null; + Pointer r = functions.bearing_tpoint_point(tptr, g, false); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // bearing(trip1, trip2) → tfloat hex-WKB, instantaneous bearing between trips + public static final UDF2 bearing = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.bearing_tpoint_tpoint(p1, p2); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // SPATIAL AGGREGATES (geometry WKT out) + // + // MEOS: tpoint_twcentroid(temp) meos_geo.h + // + // Returns the time-weighted centroid of the trip as a WKT POINT string. + // ------------------------------------------------------------------ + + // twCentroid(trip) → WKT POINT of the time-weighted centroid + public static final UDF1 twCentroid = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + Pointer g = functions.tpoint_twcentroid(tptr); + if (g == null) return null; + return functions.geo_as_text(g, 15); + }; + + // ------------------------------------------------------------------ + // geoSame(wkt1 STRING, wkt2 STRING) → BOOLEAN + // + // Returns true if two geometries are exactly equal (same type, coordinates, + // and SRID). + // + // MEOS: geo_same(const GSERIALIZED *, const GSERIALIZED *) → bool + // ------------------------------------------------------------------ + public static final UDF2 geoSame = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geo_same(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + // ------------------------------------------------------------------ + // tpointConvexHull(trip STRING) → STRING (hex-EWKB geometry) + // + // Returns the convex hull of the trajectory of the temporal point. + // + // MEOS: tgeo_convex_hull(const Temporal *) → GSERIALIZED * + // geo_as_hexewkb(const GSERIALIZED *, const char *endian) + // ------------------------------------------------------------------ + public static final UDF1 tpointConvexHull = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer gptr = functions.tgeo_convex_hull(tptr); + if (gptr == null) return null; + try { + return functions.geo_as_hexewkb(gptr, null); + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointExpandSpace(trip STRING, distance DOUBLE) → STRING (hex-WKB STBOX) + // + // Returns the spatiotemporal bounding box of the temporal point expanded + // by distance in each spatial dimension. + // + // MEOS: tspatial_to_stbox(const Temporal *) → STBox * + // stbox_expand_space(const STBox *, double d) → STBox * + // stbox_as_hexwkb(const STBox *, uint8_t variant, size_t *size) + // ------------------------------------------------------------------ + public static final UDF2 tpointExpandSpace = + (trip, distance) -> { + if (trip == null || distance == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer stbox = functions.tspatial_to_stbox(tptr); + if (stbox == null) return null; + try { + Pointer expanded = functions.stbox_expand_space(stbox, distance); + if (expanded == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(expanded, (byte) 0, sizeOut); + } finally { + MeosMemory.free(expanded); + } + } finally { + MeosMemory.free(stbox); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // geometry operations + spark.udf().register("geomBuffer", geomBuffer, DataTypes.StringType); + spark.udf().register("geomConvexHull", geomConvexHull, DataTypes.StringType); + spark.udf().register("geomIntersection", geomIntersection, DataTypes.StringType); + // SRID management + spark.udf().register("setSRID", setSRID, DataTypes.StringType); + spark.udf().register("transform", transform, DataTypes.StringType); + // text output + spark.udf().register("asText", asText, DataTypes.StringType); + spark.udf().register("asEWKT", asEWKT, DataTypes.StringType); + // elevation restriction + spark.udf().register("atElevation", atElevation, DataTypes.StringType); + // temporal predicates + spark.udf().register("tContains", tContains, DataTypes.StringType); + spark.udf().register("tCovers", tCovers, DataTypes.StringType); + spark.udf().register("tDwithin", tDwithin, DataTypes.StringType); + // bearing + spark.udf().register("bearingToPoint", bearingToPoint, DataTypes.StringType); + spark.udf().register("bearing", bearing, DataTypes.StringType); + // spatial aggregate + spark.udf().register("twCentroid", twCentroid, DataTypes.StringType); + // geometry equality + spark.udf().register("geoSame", geoSame, DataTypes.BooleanType); + // tpoint analytics + spark.udf().register("tpointConvexHull", tpointConvexHull, DataTypes.StringType); + spark.udf().register("tpointExpandSpace", tpointExpandSpace, DataTypes.StringType); + // tpoint minus geom + bearing direction + spark.udf().register("minusGeometry", minusGeometry, DataTypes.StringType); + spark.udf().register("tdirection", tdirection, DataTypes.DoubleType); + // transformPipeline (PROJ pipeline string) + spark.udf().register("transformPipeline", tpointTransformPipeline, DataTypes.StringType); + spark.udf().register("stboxTransformPipeline", stboxTransformPipeline, DataTypes.StringType); + } + + public static final org.apache.spark.sql.api.java.UDF4 + tpointTransformPipeline = (trip, pipeline, srid, isForward) -> { + if (trip == null || pipeline == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + try { + jnr.ffi.Pointer r = functions.tpoint_transform_pipeline(t, pipeline, + srid == null ? 0 : srid, isForward == null ? true : isForward); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(t); } + }; + + public static final org.apache.spark.sql.api.java.UDF4 + stboxTransformPipeline = (stboxHex, pipeline, srid, isForward) -> { + if (stboxHex == null || pipeline == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer s = functions.stbox_from_hexwkb(stboxHex); + if (s == null) return null; + try { + jnr.ffi.Pointer r = functions.stbox_transform_pipeline(s, pipeline, + srid == null ? 0 : srid, isForward == null ? true : isForward); + if (r == null) return null; + try { + jnr.ffi.Pointer sizeOut = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(s); } + }; + + // minusGeometry(tpoint, geomWkt) → tpoint with geometry subtracted (or null if total) + public static final org.apache.spark.sql.api.java.UDF2 minusGeometry = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + jnr.ffi.Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) { org.mobilitydb.spark.MeosMemory.free(t); return null; } + try { + jnr.ffi.Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.tpoint_minus_geom(t, g); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(t, g); } + }; + + // tdirection(tpoint) → bearing in radians, or null if not defined + public static final org.apache.spark.sql.api.java.UDF1 tdirection = + (trip) -> { + if (trip == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + try { + jnr.ffi.Pointer outBuf = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + boolean ok = org.mobilitydb.spark.MeosNative.INSTANCE.tpoint_direction(t, outBuf); + return ok ? outBuf.getDouble(0) : null; + } finally { org.mobilitydb.spark.MeosMemory.free(t); } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/geo/GeoUDFs.java b/src/main/java/org/mobilitydb/spark/geo/GeoUDFs.java new file mode 100644 index 00000000..738e4e82 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/GeoUDFs.java @@ -0,0 +1,953 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.apache.spark.sql.api.java.*; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +/** + * Spark SQL UDFs for spatial (geometry) operations on tgeompoint. + * + * Storage convention: + * tgeompoint → hex-WKB STRING (temporal_as_hexwkb / temporal_from_hexwkb) + * geometry → WKT STRING (e.g. "POINT(50 0)", parsed via geo_from_text) + * + * Memory management: every native Pointer allocated by MEOS must be freed via + * MeosMemory.free() in a finally block. MEOS standalone mode uses the system + * malloc/free (palloc/pfree map to malloc/free outside PostgreSQL), so native + * objects are NOT garbage-collected by the JVM. Failing to free them causes + * the native heap to grow without bound across UDF calls (one leaked object per + * row × millions of rows in cross-join queries like Q2/Q4/Q5/Q6). + * + * MEOS function authority: meos/include/meos_geo.h + */ +public final class GeoUDFs { + + private GeoUDFs() {} + + // ------------------------------------------------------------------ + // eIntersects(trip STRING, geomWkt STRING) → BOOLEAN + // + // Returns true if the trip's trajectory ever intersects geomWkt. + // + // SRID handling: extract the trip's SRID from its bounding box and + // pass it to geo_from_text so MEOS's ensure_same_srid check passes. + // BerlinMOD trips use SRID=3857; query regions use SRID=0 (plain WKT). + // + // For geodetic trips (tgeogpoint), the geometry is promoted to geography + // via geom_to_geog() to avoid MEOS "Operation on mixed SRID" errors. + // + // MEOS: geo_from_text, tspatial_to_stbox, stbox_srid, stbox_isgeodetic, + // geom_to_geog, eintersects_tgeo_geo (meos_geo.h) + // ------------------------------------------------------------------ + public static final UDF2 eIntersects = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + boolean geodetic = (bbox != null && functions.stbox_isgeodetic(bbox)); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + if (geodetic) { + Pointer geog = functions.geom_to_geog(gptr); + MeosMemory.free(gptr); + gptr = geog; + if (gptr == null) return null; + } + try { + return functions.eintersects_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // nearestApproachDistance(t1 STRING, t2 STRING) → DOUBLE + // + // MEOS: nad_tgeo_tgeo(const Temporal *, const Temporal *) → double + // Returns NULL when trips have no overlapping time extent (MEOS: DBL_MAX). + // ------------------------------------------------------------------ + public static final UDF2 nearestApproachDistance = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + double dist = functions.nad_tgeo_tgeo(p1, p2); + return (dist == Double.MAX_VALUE) ? null : dist; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // eDwithin(t1 STRING, t2 STRING, dist DOUBLE) → BOOLEAN + // + // dist accepts Double or BigDecimal (Spark infers decimal(p,s) for + // numeric literals like 10.0 — use Number.doubleValue() to handle both). + // + // MEOS: edwithin_tgeo_tgeo(const Temporal *, const Temporal *, double) → int + // ------------------------------------------------------------------ + public static final UDF3 eDwithin = + (trip1, trip2, dist) -> { + if (trip1 == null || trip2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return functions.edwithin_tgeo_tgeo(p1, p2, dist.doubleValue()) == 1; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // tgeompoint(wkt STRING) → STRING (hex-WKB) + // + // Parses a tgeompoint WKT string and returns the MEOS hex-WKB encoding. + // + // MEOS: tgeompoint_in(const char *str) → Temporal * meos_geo.h:618 + // temporal_as_hexwkb(const Temporal *, uint8_t, size_t *) meos.h + // ------------------------------------------------------------------ + public static final UDF1 tgeompoint = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tgeompoint_in(wkt); + if (p == null) return null; + try { + return functions.temporal_as_hexwkb(p, (byte) 0); + } finally { + MeosMemory.free(p); + } + }; + + // ------------------------------------------------------------------ + // trajectory(trip STRING) → STRING (hex WKB geometry) + // + // Projects a tgeompoint to its spatial path: POINT for a single + // instant, LINESTRING for a linear sequence. Returns hex-EWKB. + // + // MEOS: tpoint_trajectory(const Temporal *, bool merge) → GSERIALIZED * + // geo_as_hexewkb(const GSERIALIZED *, const char *endian) meos_geo.h + // ------------------------------------------------------------------ + public static final UDF1 trajectory = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer gptr = functions.tpoint_trajectory(tptr, true); + if (gptr == null) return null; + try { + return functions.geo_as_hexewkb(gptr, null); + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // eDisjoint(trip STRING, geomWkt STRING) → BOOLEAN + // + // Returns true if the moving object is ever disjoint from the geometry. + // + // MEOS: edisjoint_tgeo_geo(const Temporal *, const GSERIALIZED *) → int + // ------------------------------------------------------------------ + public static final UDF2 eDisjoint = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.edisjoint_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // eTouches(trip STRING, geomWkt STRING) → BOOLEAN + // + // Returns true if the moving object ever touches (shares boundary with) + // the static geometry. + // + // MEOS: etouches_tgeo_geo(const Temporal *, const GSERIALIZED *) → int + // ------------------------------------------------------------------ + public static final UDF2 eTouches = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.etouches_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // eCovers(trip STRING, geomWkt STRING) → BOOLEAN + // + // Returns true if the moving object ever covers the static geometry. + // + // MEOS: ecovers_tgeo_geo(const Temporal *, const GSERIALIZED *) → int + // ------------------------------------------------------------------ + public static final UDF2 eCovers = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.ecovers_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // eDisjointTgeoTgeo(trip1 STRING, trip2 STRING) → BOOLEAN + // eIntersectsTgeoTgeo(trip1 STRING, trip2 STRING) → BOOLEAN + // + // MEOS: edisjoint_tgeo_tgeo, eintersects_tgeo_tgeo + // ------------------------------------------------------------------ + public static final UDF2 eDisjointTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return functions.edisjoint_tgeo_tgeo(p1, p2) == 1; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 eIntersectsTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return functions.eintersects_tgeo_tgeo(p1, p2) == 1; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // aIntersects(trip STRING, geomWkt STRING) → BOOLEAN + // aDisjoint(trip STRING, geomWkt STRING) → BOOLEAN + // + // Returns true if the moving object always intersects / is always + // disjoint from the static geometry. + // + // MEOS: aintersects_tgeo_geo, adisjoint_tgeo_geo + // ------------------------------------------------------------------ + public static final UDF2 aIntersects = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.aintersects_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static final UDF2 aDisjoint = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.adisjoint_tgeo_geo(tptr, gptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // aDwithin(trip1 STRING, trip2 STRING, dist DOUBLE) → BOOLEAN + // eDwithinGeo(trip STRING, geomWkt STRING, dist DOUBLE) → BOOLEAN + // aDwithinGeo(trip STRING, geomWkt STRING, dist DOUBLE) → BOOLEAN + // + // MEOS: adwithin_tgeo_tgeo, edwithin_tgeo_geo, adwithin_tgeo_geo + // ------------------------------------------------------------------ + public static final UDF3 aDwithin = + (trip1, trip2, dist) -> { + if (trip1 == null || trip2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return functions.adwithin_tgeo_tgeo(p1, p2, dist.doubleValue()) == 1; + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF3 eDwithinGeo = + (trip, geomWkt, dist) -> { + if (trip == null || geomWkt == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.edwithin_tgeo_geo(tptr, gptr, dist.doubleValue()) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static final UDF3 aDwithinGeo = + (trip, geomWkt, dist) -> { + if (trip == null || geomWkt == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.adwithin_tgeo_geo(tptr, gptr, dist.doubleValue()) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // eContains(geomWKT STRING, trip STRING) → BOOLEAN + // + // Returns true if the static geometry ever contains the moving object. + // Argument order: eContains(container, contained). + // + // MEOS: econtains_geo_tgeo(const GSERIALIZED *, const Temporal *) → int + // ------------------------------------------------------------------ + public static final UDF2 eContains = + (geomWkt, trip) -> { + if (geomWkt == null || trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer bbox = functions.tspatial_to_stbox(tptr); + int srid = (bbox != null) ? functions.stbox_srid(bbox) : 0; + MeosMemory.free(bbox); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return functions.econtains_geo_tgeo(gptr, tptr) == 1; + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // geomFromText(wkt STRING) → STRING (hex-EWKB) + // + // MEOS: geo_from_text(const char *, int32_t srid) → GSERIALIZED * + // geo_as_hexewkb(const GSERIALIZED *, const char *) + // ------------------------------------------------------------------ + public static final UDF1 geomFromText = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.geo_from_text(wkt, 0); + if (p == null) return null; + try { + return functions.geo_as_hexewkb(p, null); + } finally { + MeosMemory.free(p); + } + }; + + // ------------------------------------------------------------------ + // getX / getY / getZ(trip STRING) → STRING (tfloat hex-WKB) + // cumulativeLength(trip STRING) → STRING (tfloat hex-WKB) + // + // MEOS: tpoint_get_x/y/z, tpoint_cumulative_length meos_geo.h + // ------------------------------------------------------------------ + public static final UDF1 getX = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer r = functions.tpoint_get_x(tptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static final UDF1 getY = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer r = functions.tpoint_get_y(tptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static final UDF1 getZ = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + // tpoint_get_z raises a MEOS error for 2D points; guard with Z-presence check. + Pointer bbox = functions.tspatial_to_stbox(tptr); + if (bbox == null || !functions.stbox_hasz(bbox)) { + MeosMemory.free(bbox); + return null; + } + MeosMemory.free(bbox); + Pointer r = functions.tpoint_get_z(tptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static final UDF1 cumulativeLength = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer r = functions.tpoint_cumulative_length(tptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // stops(trip STRING, maxDist DOUBLE, minDuration STRING) → STRING + // + // Returns the sub-trajectories where the vehicle stayed within maxDist + // for at least minDuration ("1 second"). + // + // MEOS: temporal_stops(const Temporal *, double, const Interval *) meos.h + // ------------------------------------------------------------------ + public static final UDF3 stops = + (trip, maxDist, minDuration) -> { + if (trip == null || maxDist == null || minDuration == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer iv = functions.pg_interval_in(minDuration, -1); + if (iv == null) return null; + try { + Pointer r = functions.temporal_stops(tptr, maxDist, iv); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(iv); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // isSimple(trip STRING) → BOOLEAN + // + // True when the trip has no self-intersections. + // + // MEOS: tpoint_is_simple(const Temporal *) meos_geo.h + // ------------------------------------------------------------------ + public static final UDF1 isSimple = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + return functions.tpoint_is_simple(tptr); + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // shortestLine(trip1 STRING, trip2 STRING) → STRING (WKT geometry) + // + // MEOS: shortestline_tpoint_tpoint(const Temporal *, const Temporal *) + // geo_as_text(const GSERIALIZED *, int precision) + // ------------------------------------------------------------------ + public static final UDF2 shortestLine = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + Pointer g = functions.shortestline_tgeo_tgeo(p1, p2); + if (g == null) return null; + try { + return functions.geo_as_text(g, 15); + } finally { + MeosMemory.free(g); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // tpointTransform(trip STRING, srid INTEGER) → STRING + // + // Reprojects all instants of the temporal point to a different CRS. + // + // MEOS: tspatial_transform(const Temporal *, int srid) → Temporal * + // ------------------------------------------------------------------ + public static final UDF2 tpointTransform = + (trip, srid) -> { + if (trip == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer result = functions.tspatial_transform(tptr, srid); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointAsText(trip STRING, precision INTEGER) → STRING + // + // Returns WKT for each instant of the temporal point. + // + // MEOS: tspatial_as_text(const Temporal *, int precision) → char * + // ------------------------------------------------------------------ + public static final UDF2 tpointAsText = + (trip, precision) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + return functions.tspatial_as_text(tptr, precision != null ? precision : 15); + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointAsEWKT(trip STRING, precision INTEGER) → STRING + // + // Returns Extended WKT (SRID=N;...) for each instant of the temporal point. + // + // MEOS: tspatial_as_ewkt(const Temporal *, int precision) → char * + // ------------------------------------------------------------------ + public static final UDF2 tpointAsEWKT = + (trip, precision) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + return functions.tspatial_as_ewkt(tptr, precision != null ? precision : 15); + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointSRID(trip STRING) → INTEGER + // + // Returns the SRID of the temporal point via its bounding box. + // + // MEOS: tspatial_to_stbox(const Temporal *) → STBox * + // stbox_srid(const STBox *) → int + // ------------------------------------------------------------------ + public static final UDF1 tpointSRID = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer stbox = functions.tspatial_to_stbox(tptr); + if (stbox == null) return null; + try { + return functions.stbox_srid(stbox); + } finally { + MeosMemory.free(stbox); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointSetSRID(trip STRING, srid INTEGER) → STRING + // + // Returns a copy of the temporal point with SRID set to srid. + // + // MEOS: tspatial_set_srid(const Temporal *, int srid) → Temporal * + // ------------------------------------------------------------------ + public static final UDF2 tpointSetSRID = + (trip, srid) -> { + if (trip == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer result = functions.tspatial_set_srid(tptr, srid); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointRound(trip STRING, decimals INTEGER) → STRING + // + // Returns the temporal point with coordinates rounded to decimals places. + // + // MEOS: temporal_round(const Temporal *, int maxdd) → Temporal * + // ------------------------------------------------------------------ + public static final UDF2 tpointRound = + (trip, decimals) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer result = functions.temporal_round(tptr, decimals != null ? decimals : 6); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // tpointToStbox(trip STRING) → STRING (hex-WKB STBOX) + // + // Returns the spatiotemporal bounding box of the temporal point. + // + // MEOS: tspatial_to_stbox(const Temporal *) → STBox * + // stbox_as_hexwkb(const STBox *, uint8_t variant, size_t *size) + // ------------------------------------------------------------------ + public static final UDF1 tpointToStbox = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer stbox = functions.tspatial_to_stbox(tptr); + if (stbox == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(stbox, (byte) 0, sizeOut); + } finally { + MeosMemory.free(stbox); + } + } finally { + MeosMemory.free(tptr); + } + }; + + public static void registerAll(org.apache.spark.sql.SparkSession spark) { + spark.udf().register("eIntersects", eIntersects, DataTypes.BooleanType); + spark.udf().register("eDisjoint", eDisjoint, DataTypes.BooleanType); + spark.udf().register("eTouches", eTouches, DataTypes.BooleanType); + spark.udf().register("eCovers", eCovers, DataTypes.BooleanType); + spark.udf().register("eContains", eContains, DataTypes.BooleanType); + spark.udf().register("eDisjointTgeoTgeo", eDisjointTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("eIntersectsTgeoTgeo", eIntersectsTgeoTgeo, DataTypes.BooleanType); + spark.udf().register("nearestApproachDistance", nearestApproachDistance, DataTypes.DoubleType); + spark.udf().register("eDwithin", eDwithin, DataTypes.BooleanType); + spark.udf().register("eDwithinGeo", eDwithinGeo, DataTypes.BooleanType); + spark.udf().register("aIntersects", aIntersects, DataTypes.BooleanType); + spark.udf().register("aDisjoint", aDisjoint, DataTypes.BooleanType); + spark.udf().register("aDwithin", aDwithin, DataTypes.BooleanType); + spark.udf().register("aDwithinGeo", aDwithinGeo, DataTypes.BooleanType); + spark.udf().register("tgeompoint", tgeompoint, DataTypes.StringType); + spark.udf().register("trajectory", trajectory, DataTypes.StringType); + spark.udf().register("geomFromText", geomFromText, DataTypes.StringType); + spark.udf().register("getX", getX, DataTypes.StringType); + spark.udf().register("getY", getY, DataTypes.StringType); + spark.udf().register("getZ", getZ, DataTypes.StringType); + spark.udf().register("cumulativeLength", cumulativeLength, DataTypes.StringType); + spark.udf().register("stops", stops, DataTypes.StringType); + spark.udf().register("isSimple", isSimple, DataTypes.BooleanType); + spark.udf().register("shortestLine", shortestLine, DataTypes.StringType); + spark.udf().register("tpointTransform", tpointTransform, DataTypes.StringType); + spark.udf().register("tpointAsText", tpointAsText, DataTypes.StringType); + spark.udf().register("tpointAsEWKT", tpointAsEWKT, DataTypes.StringType); + spark.udf().register("tpointSRID", tpointSRID, DataTypes.IntegerType); + spark.udf().register("tpointSetSRID", tpointSetSRID, DataTypes.StringType); + spark.udf().register("tpointRound", tpointRound, DataTypes.StringType); + spark.udf().register("tpointToStbox", tpointToStbox, DataTypes.StringType); + spark.udf().register("geoAsEwkt", geoAsEwkt, DataTypes.StringType); + spark.udf().register("geoAsGeojson", geoAsGeojson, DataTypes.StringType); + spark.udf().register("geoFromGeojson", geoFromGeojson, DataTypes.StringType); + } + + // ------------------------------------------------------------------ + // geoAsEwkt(wkt STRING, precision INTEGER) → STRING + // + // Returns Extended WKT (SRID=N;...) for a geometry given as WKT. + // + // MEOS: geo_as_ewkt(const GSERIALIZED *, int precision) + // ------------------------------------------------------------------ + public static final UDF2 geoAsEwkt = + (wkt, precision) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + int prec = (precision == null) ? 15 : precision; + Pointer gptr = functions.geo_from_text(wkt, 0); + if (gptr == null) return null; + try { + return functions.geo_as_ewkt(gptr, prec); + } finally { + MeosMemory.free(gptr); + } + }; + + // ------------------------------------------------------------------ + // geoAsGeojson(wkt STRING, options INTEGER, precision INTEGER) → STRING + // + // Returns GeoJSON for a geometry. options: 0=no bbox, 1=bbox, 2=short CRS. + // + // MEOS: geo_as_geojson(const GSERIALIZED *, int options, int precision, + // const char *srs) + // ------------------------------------------------------------------ + public static final UDF3 geoAsGeojson = + (wkt, options, precision) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + int opts = (options == null) ? 0 : options; + int prec = (precision == null) ? 9 : precision; + Pointer gptr = functions.geo_from_text(wkt, 0); + if (gptr == null) return null; + try { + return functions.geo_as_geojson(gptr, opts, prec, null); + } finally { + MeosMemory.free(gptr); + } + }; + + // ------------------------------------------------------------------ + // geoFromGeojson(geojson STRING) → STRING (WKT) + // + // Parses GeoJSON and returns the geometry as WKT. + // + // MEOS: geo_from_geojson(const char *) → GSERIALIZED * + // geo_as_text(const GSERIALIZED *, int precision) + // ------------------------------------------------------------------ + public static final UDF1 geoFromGeojson = + (geojson) -> { + if (geojson == null) return null; + MeosThread.ensureReady(); + Pointer gptr = functions.geo_from_geojson(geojson); + if (gptr == null) return null; + try { + return functions.geo_as_text(gptr, 15); + } finally { + MeosMemory.free(gptr); + } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/geo/STBoxUDFs.java b/src/main/java/org/mobilitydb/spark/geo/STBoxUDFs.java new file mode 100644 index 00000000..4497cfc0 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/STBoxUDFs.java @@ -0,0 +1,695 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.api.java.UDF4; +import org.apache.spark.sql.api.java.UDF5; +import org.apache.spark.sql.api.java.UDF6; +import org.apache.spark.sql.api.java.UDF7; +import org.apache.spark.sql.types.DataTypes; + +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for STBox accessor and expansion operations. + * + * Storage convention: STBox values are stored as hex-WKB strings produced by + * stbox_as_hexwkb (which requires a non-null size_out scratch Pointer). + * + * Spatial bound accessors (xmin/xmax/ymin/ymax/zmin/zmax): the JMEOS wrapper + * allocates an 8-byte buffer, passes it as out-pointer to the C function which + * writes the double there, and returns the buffer Pointer (null = absent). + * Temporal bound accessors (tmin/tmax): same pattern, int64 PG-epoch μs. + * Inclusivity flag accessors (tmin_inc/tmax_inc): same pattern, byte (0/1). + * + * MEOS function authority: meos/include/meos_geo.h + */ +public final class STBoxUDFs { + + private STBoxUDFs() {} + + // milliseconds from Unix epoch (1970-01-01) to PG epoch (2000-01-01) + private static final long PG_UNIX_OFFSET_MS = 946684800L * 1000L; + + private static Pointer stboxPtr(String hex) { + if (hex == null) return null; + return functions.stbox_from_hexwkb(hex); + } + + // stbox_as_hexwkb requires a non-null size_out scratch Pointer + private static String stboxHex(Pointer p) { + if (p == null) return null; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(p, (byte) 0, sizeOut); + } + + // ------------------------------------------------------------------ + // Has-component flags + // ------------------------------------------------------------------ + + public static final UDF1 stboxHasx = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + return p == null ? null : functions.stbox_hasx(p); + }; + + public static final UDF1 stboxHast = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + return p == null ? null : functions.stbox_hast(p); + }; + + public static final UDF1 stboxHasz = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + return p == null ? null : functions.stbox_hasz(p); + }; + + // ------------------------------------------------------------------ + // Spatial bound accessors (Pointer → double at offset 0) + // ------------------------------------------------------------------ + + public static final UDF1 stboxXmin = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_xmin(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 stboxXmax = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_xmax(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 stboxYmin = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_ymin(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 stboxYmax = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_ymax(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 stboxZmin = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_zmin(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 stboxZmax = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_zmax(p); + return r == null ? null : r.getDouble(0); + }; + + // ------------------------------------------------------------------ + // Temporal bound accessors (Pointer → int64 PG-epoch μs at offset 0) + // ------------------------------------------------------------------ + + public static final UDF1 stboxTmin = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_tmin(p); + if (r == null) return null; + return new java.sql.Timestamp(r.getLong(0) / 1000L + PG_UNIX_OFFSET_MS); + }; + + public static final UDF1 stboxTmax = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_tmax(p); + if (r == null) return null; + return new java.sql.Timestamp(r.getLong(0) / 1000L + PG_UNIX_OFFSET_MS); + }; + + // ------------------------------------------------------------------ + // Temporal inclusivity flags (Pointer → byte at offset 0) + // ------------------------------------------------------------------ + + public static final UDF1 stboxTminInc = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_tmin_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + public static final UDF1 stboxTmaxInc = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_tmax_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + // ------------------------------------------------------------------ + // SRID + // ------------------------------------------------------------------ + + public static final UDF1 stboxSrid = + (hex) -> { + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + return p == null ? null : functions.stbox_srid(p); + }; + + // ------------------------------------------------------------------ + // Expansion operations + // ------------------------------------------------------------------ + + // stboxExpandSpace(stboxHex STRING, d DOUBLE) → STRING + public static final UDF2 stboxExpandSpace = + (hex, d) -> { + if (hex == null || d == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer r = functions.stbox_expand_space(p, d); + return stboxHex(r); + }; + + // stboxExpandTime(stboxHex STRING, intervalStr STRING) → STRING + public static final UDF2 stboxExpandTime = + (hex, intervalStr) -> { + if (hex == null || intervalStr == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + Pointer r = functions.stbox_expand_time(p, iv); + return stboxHex(r); + }; + + // ------------------------------------------------------------------ + // Spatial analytics (hex-WKB in, scalar out) + // + // MEOS: stbox_area(box, spheroid) meos_geo.h + // stbox_perimeter(box, spheroid) meos_geo.h + // stbox_volume(box) meos_geo.h + // ------------------------------------------------------------------ + + public static final UDF1 stboxArea = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + return functions.stbox_area(p, false); + }; + + public static final UDF1 stboxPerimeter = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + return functions.stbox_perimeter(p, false); + }; + + public static final UDF1 stboxVolume = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + return functions.stbox_volume(p); + }; + + // stboxIsGeodetic(hex) → Boolean + public static final UDF1 stboxIsGeodetic = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + return functions.stbox_isgeodetic(p); + }; + + // stboxToGeo(hex) → WKT of the bounding envelope polygon + public static final UDF1 stboxToGeo = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer g = functions.stbox_to_geo(p); + if (g == null) return null; + return functions.geo_as_text(g, 15); + }; + + // stboxToTstzspan(hex) → tstzspan hex-WKB + public static final UDF1 stboxToTstzspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer span = functions.stbox_to_tstzspan(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Rounding + // ------------------------------------------------------------------ + + // stboxRound(hex STRING, maxDecimals INT) → STRING + // MEOS: stbox_round(const STBox *, int) → STBox * + public static final UDF2 stboxRound = + (hex, maxDecimals) -> { + if (hex == null || maxDecimals == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer result = functions.stbox_round(p, maxDecimals); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // SRID assignment + // ------------------------------------------------------------------ + + // stboxSetSrid(hex STRING, srid INT) → STRING + // MEOS: stbox_set_srid(const STBox *, int) → STBox * + public static final UDF2 stboxSetSrid = + (hex, srid) -> { + if (hex == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer result = functions.stbox_set_srid(p, srid); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // Time-domain shifting and scaling + // ------------------------------------------------------------------ + + // stboxShiftScaleTime(hex STRING, shift STRING, scale STRING) → STRING + // MEOS: stbox_shift_scale_time(const STBox *, Interval *, Interval *) → STBox * + // Either shift or scale may be null (pass null to MEOS for no-op). + public static final UDF3 stboxShiftScaleTime = + (hex, shift, scale) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer shiftIv = shift == null ? null : functions.pg_interval_in(shift, Integer.MIN_VALUE); + Pointer scaleIv = scale == null ? null : functions.pg_interval_in(scale, Integer.MIN_VALUE); + try { + Pointer result = functions.stbox_shift_scale_time(p, shiftIv, scaleIv); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + } finally { + if (shiftIv != null) MeosMemory.free(shiftIv); + if (scaleIv != null) MeosMemory.free(scaleIv); + } + }; + + // ------------------------------------------------------------------ + // STBox constructors from geometry / span / timestamptz + // + // MEOS: geo_to_stbox, tstzspan_to_stbox, timestamptz_to_stbox + // ------------------------------------------------------------------ + + // geoToStbox(wkt STRING) → STBox hex-WKB + // Creates an STBox with the bounding box of a geometry. + // MEOS: geo_to_stbox(const GSERIALIZED *) → STBox * + public static final UDF1 geoToStbox = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer geo = functions.geo_from_text(wkt, 0); + if (geo == null) return null; + Pointer result = functions.geo_to_stbox(geo); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + // tstzspanToStbox(spanHex STRING) → STBox hex-WKB + // Creates a time-only STBox from a tstzspan. + // MEOS: tstzspan_to_stbox(const Span *) → STBox * + public static final UDF1 tstzspanToStbox = + (spanHex) -> { + if (spanHex == null) return null; + MeosThread.ensureReady(); + Pointer span = functions.span_from_hexwkb(spanHex); + if (span == null) return null; + Pointer result = functions.tstzspan_to_stbox(span); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + // timestamptzToStbox(ts TIMESTAMP) → STBox hex-WKB + // Creates a point-time STBox from a single timestamp. + // MEOS: timestamptz_to_stbox(TimestampTz) → STBox * + public static final UDF1 timestamptzToStbox = + (ts) -> { + if (ts == null) return null; + MeosThread.ensureReady(); + long pgMicros = (ts.getTime() - PG_UNIX_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pgMicros, 0), ZoneOffset.UTC); + Pointer result = functions.timestamptz_to_stbox(odt); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // Spatial component extraction + // + // MEOS: stbox_get_space(const STBox *) → STBox * (spatial dims only, no T) + // ------------------------------------------------------------------ + + public static final UDF1 stboxGetSpace = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = stboxPtr(hex); + if (p == null) return null; + Pointer result = functions.stbox_get_space(p); + if (result == null) return null; + try { + return stboxHex(result); + } finally { + MeosMemory.free(result); + } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("stboxHasx", stboxHasx, DataTypes.BooleanType); + spark.udf().register("stboxHast", stboxHast, DataTypes.BooleanType); + spark.udf().register("stboxHasz", stboxHasz, DataTypes.BooleanType); + spark.udf().register("stboxXmin", stboxXmin, DataTypes.DoubleType); + spark.udf().register("stboxXmax", stboxXmax, DataTypes.DoubleType); + spark.udf().register("stboxYmin", stboxYmin, DataTypes.DoubleType); + spark.udf().register("stboxYmax", stboxYmax, DataTypes.DoubleType); + spark.udf().register("stboxZmin", stboxZmin, DataTypes.DoubleType); + spark.udf().register("stboxZmax", stboxZmax, DataTypes.DoubleType); + spark.udf().register("stboxTmin", stboxTmin, DataTypes.TimestampType); + spark.udf().register("stboxTmax", stboxTmax, DataTypes.TimestampType); + spark.udf().register("stboxTminInc", stboxTminInc, DataTypes.BooleanType); + spark.udf().register("stboxTmaxInc", stboxTmaxInc, DataTypes.BooleanType); + spark.udf().register("stboxSrid", stboxSrid, DataTypes.IntegerType); + spark.udf().register("stboxExpandSpace", stboxExpandSpace, DataTypes.StringType); + spark.udf().register("stboxExpandTime", stboxExpandTime, DataTypes.StringType); + spark.udf().register("stboxArea", stboxArea, DataTypes.DoubleType); + spark.udf().register("stboxPerimeter", stboxPerimeter, DataTypes.DoubleType); + spark.udf().register("stboxVolume", stboxVolume, DataTypes.DoubleType); + spark.udf().register("stboxIsGeodetic", stboxIsGeodetic, DataTypes.BooleanType); + spark.udf().register("stboxToGeo", stboxToGeo, DataTypes.StringType); + spark.udf().register("stboxToTstzspan", stboxToTstzspan, DataTypes.StringType); + spark.udf().register("stboxRound", stboxRound, DataTypes.StringType); + spark.udf().register("stboxSetSrid", stboxSetSrid, DataTypes.StringType); + spark.udf().register("stboxShiftScaleTime", stboxShiftScaleTime, DataTypes.StringType); + spark.udf().register("stboxGetSpace", stboxGetSpace, DataTypes.StringType); + // STBox constructors from geometry / span / timestamp + spark.udf().register("geoToStbox", geoToStbox, DataTypes.StringType); + spark.udf().register("tstzspanToStbox", tstzspanToStbox, DataTypes.StringType); + spark.udf().register("timestamptzToStbox", timestamptzToStbox, DataTypes.StringType); + // STBox set operations + spark.udf().register("intersectionStboxStbox", intersectionStboxStbox, DataTypes.StringType); + spark.udf().register("unionStboxStbox", unionStboxStbox, DataTypes.StringType); + // MobilityDB SQL bare-name aliases for the same lambdas + spark.udf().register("stboxIntersection", intersectionStboxStbox, DataTypes.StringType); + spark.udf().register("stboxUnion", unionStboxStbox, DataTypes.StringType); + // Typed STBox constructors + spark.udf().register("stboxX", stboxX, DataTypes.StringType); + spark.udf().register("stboxT", stboxT, DataTypes.StringType); + spark.udf().register("stboxXT", stboxXT, DataTypes.StringType); + spark.udf().register("stboxZ", stboxZ, DataTypes.StringType); + spark.udf().register("stboxZT", stboxZT, DataTypes.StringType); + spark.udf().register("geodstboxZ", geodstboxZ, DataTypes.StringType); + spark.udf().register("geodstboxT", geodstboxT, DataTypes.StringType); + spark.udf().register("geodstboxZT", geodstboxZT, DataTypes.StringType); + // STBox topology predicates (stbox, stbox) + spark.udf().register("stboxContains", stboxContains, DataTypes.BooleanType); + spark.udf().register("stboxContained", stboxContained, DataTypes.BooleanType); + spark.udf().register("stboxOverlaps", stboxOverlaps, DataTypes.BooleanType); + // STBox positional predicates (stbox, stbox) + spark.udf().register("stboxLeft", stboxLeft, DataTypes.BooleanType); + spark.udf().register("stboxOverleft", stboxOverleft, DataTypes.BooleanType); + spark.udf().register("stboxRight", stboxRight, DataTypes.BooleanType); + spark.udf().register("stboxOverright", stboxOverright, DataTypes.BooleanType); + spark.udf().register("stboxBelow", stboxBelow, DataTypes.BooleanType); + spark.udf().register("stboxOverbelow", stboxOverbelow, DataTypes.BooleanType); + spark.udf().register("stboxAbove", stboxAbove, DataTypes.BooleanType); + spark.udf().register("stboxOverabove", stboxOverabove, DataTypes.BooleanType); + spark.udf().register("stboxBefore", stboxBefore, DataTypes.BooleanType); + spark.udf().register("stboxOverbefore", stboxOverbefore, DataTypes.BooleanType); + spark.udf().register("stboxAfter", stboxAfter, DataTypes.BooleanType); + spark.udf().register("stboxOverafter", stboxOverafter, DataTypes.BooleanType); + spark.udf().register("stboxAdjacent", stboxAdjacent, DataTypes.BooleanType); + } + + // ------------------------------------------------------------------ + // STBox set operations + // MEOS: intersection_stbox_stbox(STBox *, STBox *) → STBox * (NULL if empty) + // union_stbox_stbox(STBox *, STBox *, bool strict) → STBox * + // ------------------------------------------------------------------ + + private static String stboxBinOp(String h1, String h2, + java.util.function.BiFunction fn) { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = stboxPtr(h1), p2 = stboxPtr(h2); + if (p1 == null || p2 == null) return null; + try { + Pointer r = fn.apply(p1, p2); + if (r == null) return null; + try { + return stboxHex(r); + } finally { MeosMemory.free(r); } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + } + + public static final UDF2 intersectionStboxStbox = + (h1, h2) -> stboxBinOp(h1, h2, functions::intersection_stbox_stbox); + + public static final UDF2 unionStboxStbox = + (h1, h2) -> stboxBinOp(h1, h2, (p1, p2) -> functions.union_stbox_stbox(p1, p2, false)); + + // ------------------------------------------------------------------ + // STBox positional predicates (stbox, stbox) → Boolean + // MEOS: left/overleft/right/overright/below/overbelow/above/overabove/ + // before/overbefore/after/overafter/adjacent_stbox_stbox → bool + // ------------------------------------------------------------------ + + private static Boolean stboxBoolOp(String h1, String h2, + java.util.function.BiFunction fn) { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = stboxPtr(h1), p2 = stboxPtr(h2); + if (p1 == null || p2 == null) return null; + return fn.apply(p1, p2); + } + + // ------------------------------------------------------------------ + // STBox topology predicates (stbox, stbox) → Boolean + // MEOS: contains/contained/overlaps_stbox_stbox → bool + // ------------------------------------------------------------------ + + public static final UDF2 stboxContains = + (h1, h2) -> stboxBoolOp(h1, h2, functions::contains_stbox_stbox); + public static final UDF2 stboxContained = + (h1, h2) -> stboxBoolOp(h1, h2, functions::contained_stbox_stbox); + public static final UDF2 stboxOverlaps = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overlaps_stbox_stbox); + + public static final UDF2 stboxLeft = + (h1, h2) -> stboxBoolOp(h1, h2, functions::left_stbox_stbox); + public static final UDF2 stboxOverleft = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overleft_stbox_stbox); + public static final UDF2 stboxRight = + (h1, h2) -> stboxBoolOp(h1, h2, functions::right_stbox_stbox); + public static final UDF2 stboxOverright = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overright_stbox_stbox); + public static final UDF2 stboxBelow = + (h1, h2) -> stboxBoolOp(h1, h2, functions::below_stbox_stbox); + public static final UDF2 stboxOverbelow = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overbelow_stbox_stbox); + public static final UDF2 stboxAbove = + (h1, h2) -> stboxBoolOp(h1, h2, functions::above_stbox_stbox); + public static final UDF2 stboxOverabove = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overabove_stbox_stbox); + public static final UDF2 stboxBefore = + (h1, h2) -> stboxBoolOp(h1, h2, functions::before_stbox_stbox); + public static final UDF2 stboxOverbefore = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overbefore_stbox_stbox); + public static final UDF2 stboxAfter = + (h1, h2) -> stboxBoolOp(h1, h2, functions::after_stbox_stbox); + public static final UDF2 stboxOverafter = + (h1, h2) -> stboxBoolOp(h1, h2, functions::overafter_stbox_stbox); + public static final UDF2 stboxAdjacent = + (h1, h2) -> stboxBoolOp(h1, h2, functions::adjacent_stbox_stbox); + + // ------------------------------------------------------------------ + // Typed STBox constructors — delegate to stbox_make with the correct + // hasx/hasz/geodetic/srid flags. tstzspan input is hex-WKB. + // MEOS: stbox_make(hasx, hasz, geodetic, srid, xmin, ymin, zmin, xmax, + // ymax, zmax, periodPtr) → STBox* + // ------------------------------------------------------------------ + + private static String stboxMakeHelper(boolean hasx, boolean hasz, boolean geodetic, int srid, + double xmin, double ymin, double zmin, double xmax, double ymax, double zmax, + String tstzspanHex) { + MeosThread.ensureReady(); + Pointer period = (tstzspanHex == null) ? null : functions.span_from_hexwkb(tstzspanHex); + try { + Pointer p = functions.stbox_make(hasx, hasz, geodetic, srid, + xmin, ymin, zmin, xmax, ymax, zmax, period); + if (p == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { MeosMemory.free(p); } + } finally { if (period != null) MeosMemory.free(period); } + } + + // stboxX(xmin, ymin, xmax, ymax) — 2D spatial box, no time, no geodetic + public static final UDF4 stboxX = + (xmin, ymin, xmax, ymax) -> { + if (xmin == null || ymin == null || xmax == null || ymax == null) return null; + return stboxMakeHelper(true, false, false, 0, xmin, ymin, 0, xmax, ymax, 0, null); + }; + + // stboxT(tstzspanHex) — time-only box + public static final UDF1 stboxT = + tstzspanHex -> { + if (tstzspanHex == null) return null; + return stboxMakeHelper(false, false, false, 0, 0, 0, 0, 0, 0, 0, tstzspanHex); + }; + + // stboxXT(xmin, ymin, xmax, ymax, tstzspanHex) + public static final UDF5 stboxXT = + (xmin, ymin, xmax, ymax, tstzspanHex) -> { + if (xmin == null || ymin == null || xmax == null || ymax == null || tstzspanHex == null) return null; + return stboxMakeHelper(true, false, false, 0, xmin, ymin, 0, xmax, ymax, 0, tstzspanHex); + }; + + // stboxZ(xmin, ymin, zmin, xmax, ymax, zmax) — 3D spatial box + public static final UDF6 stboxZ = + (xmin, ymin, zmin, xmax, ymax, zmax) -> { + if (xmin == null || ymin == null || zmin == null || xmax == null || ymax == null || zmax == null) return null; + return stboxMakeHelper(true, true, false, 0, xmin, ymin, zmin, xmax, ymax, zmax, null); + }; + + // stboxZT(xmin, ymin, zmin, xmax, ymax, zmax, tstzspanHex) — 3D + time + public static final UDF7 stboxZT = + (xmin, ymin, zmin, xmax, ymax, zmax, tstzspanHex) -> { + if (xmin == null || ymin == null || zmin == null || xmax == null || ymax == null || zmax == null || tstzspanHex == null) return null; + return stboxMakeHelper(true, true, false, 0, xmin, ymin, zmin, xmax, ymax, zmax, tstzspanHex); + }; + + // Geodetic variants — geodetic=true, default SRID 4326 + public static final UDF6 geodstboxZ = + (xmin, ymin, zmin, xmax, ymax, zmax) -> { + if (xmin == null || ymin == null || zmin == null || xmax == null || ymax == null || zmax == null) return null; + return stboxMakeHelper(true, true, true, 4326, xmin, ymin, zmin, xmax, ymax, zmax, null); + }; + + public static final UDF1 geodstboxT = + tstzspanHex -> { + if (tstzspanHex == null) return null; + return stboxMakeHelper(false, false, true, 4326, 0, 0, 0, 0, 0, 0, tstzspanHex); + }; + + public static final UDF7 geodstboxZT = + (xmin, ymin, zmin, xmax, ymax, zmax, tstzspanHex) -> { + if (xmin == null || ymin == null || zmin == null || xmax == null || ymax == null || zmax == null || tstzspanHex == null) return null; + return stboxMakeHelper(true, true, true, 4326, xmin, ymin, zmin, xmax, ymax, zmax, tstzspanHex); + }; +} diff --git a/src/main/java/org/mobilitydb/spark/geo/StaticGeoUDFs.java b/src/main/java/org/mobilitydb/spark/geo/StaticGeoUDFs.java new file mode 100644 index 00000000..281a622a --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/StaticGeoUDFs.java @@ -0,0 +1,409 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +/** + * Spark SQL UDFs for static (non-temporal) geometry operations. + * + * All inputs and WKT/WKB outputs use WKT string encoding via geo_from_text / + * geo_as_text. Scalar outputs (Double, Boolean) are returned as Java primitives. + * + * Memory management: every Pointer returned by MEOS must be freed via + * MeosMemory.free() in a finally block. + * + * MEOS function authority: meos/include/meos_geo.h + */ +public final class StaticGeoUDFs { + + private StaticGeoUDFs() {} + + // ------------------------------------------------------------------ + // Geometry predicates (WKT × WKT → Boolean) + // ------------------------------------------------------------------ + + public static final UDF2 geomContains = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_contains(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF2 geomCovers = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_covers(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF2 geomDisjoint = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_disjoint2d(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF2 geomIntersects = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_intersects2d(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF2 geomTouches = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_touches(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF3 geomDwithin = + (wkt1, wkt2, dist) -> { + if (wkt1 == null || wkt2 == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_dwithin2d(g1, g2, dist.doubleValue()); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + // ------------------------------------------------------------------ + // Geometry metrics (WKT → Double) + // ------------------------------------------------------------------ + + public static final UDF2 geomDistance = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + return functions.geom_distance2d(g1, g2); + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF1 geomLength = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + return functions.geom_length(g); + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF1 geomPerimeter = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + return functions.geom_perimeter(g); + } finally { + MeosMemory.free(g); + } + }; + + // ------------------------------------------------------------------ + // Geometry transforms (WKT → WKT) + // ------------------------------------------------------------------ + + public static final UDF1 geomCentroid = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.geom_centroid(g); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF1 geomBoundary = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.geom_boundary(g); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF2 geomDifference = + (wkt1, wkt2) -> { + if (wkt1 == null || wkt2 == null) return null; + MeosThread.ensureReady(); + Pointer g1 = functions.geo_from_text(wkt1, 0); + if (g1 == null) return null; + try { + Pointer g2 = functions.geo_from_text(wkt2, 0); + if (g2 == null) return null; + try { + Pointer r = functions.geom_difference2d(g1, g2); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g2); + } + } finally { + MeosMemory.free(g1); + } + }; + + public static final UDF2 geomUnaryUnion = + (wkt, prec) -> { + if (wkt == null || prec == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.geom_unary_union(g, prec); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF1 geoReverse = + (wkt) -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.geo_reverse(g); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF2 geoRound = + (wkt, maxdd) -> { + if (wkt == null || maxdd == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.geo_round(g, maxdd); + if (r == null) return null; + try { + return functions.geo_as_text(r, maxdd); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + // ------------------------------------------------------------------ + // Line functions (WKT → WKT) + // ------------------------------------------------------------------ + + public static final UDF2 lineInterpolatePoint = + (wkt, fraction) -> { + if (wkt == null || fraction == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.line_interpolate_point(g, fraction, false); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + public static final UDF3 lineSubstring = + (wkt, from, to) -> { + if (wkt == null || from == null || to == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(wkt, 0); + if (g == null) return null; + try { + Pointer r = functions.line_substring(g, from, to); + if (r == null) return null; + try { + return functions.geo_as_text(r, 15); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(g); + } + }; + + // ------------------------------------------------------------------ + // Registration + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + spark.udf().register("geomContains", geomContains, DataTypes.BooleanType); + spark.udf().register("geomCovers", geomCovers, DataTypes.BooleanType); + spark.udf().register("geomDisjoint", geomDisjoint, DataTypes.BooleanType); + spark.udf().register("geomIntersects", geomIntersects, DataTypes.BooleanType); + spark.udf().register("geomTouches", geomTouches, DataTypes.BooleanType); + spark.udf().register("geomDwithin", geomDwithin, DataTypes.BooleanType); + spark.udf().register("geomDistance", geomDistance, DataTypes.DoubleType); + spark.udf().register("geomLength", geomLength, DataTypes.DoubleType); + spark.udf().register("geomPerimeter", geomPerimeter, DataTypes.DoubleType); + spark.udf().register("geomCentroid", geomCentroid, DataTypes.StringType); + spark.udf().register("geomBoundary", geomBoundary, DataTypes.StringType); + spark.udf().register("geomDifference", geomDifference, DataTypes.StringType); + spark.udf().register("geomUnaryUnion", geomUnaryUnion, DataTypes.StringType); + spark.udf().register("geoReverse", geoReverse, DataTypes.StringType); + spark.udf().register("geoRound", geoRound, DataTypes.StringType); + spark.udf().register("lineInterpolatePoint", lineInterpolatePoint, DataTypes.StringType); + spark.udf().register("lineSubstring", lineSubstring, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFs.java b/src/main/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFs.java new file mode 100644 index 00000000..2b72dacc --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFs.java @@ -0,0 +1,519 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosNative; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for cross-type positional and topological predicates between + * STBox and tgeopoint (tspatial). + * + * MEOS function authority: meos/include/meos_geo.h + * + * Naming: stbox = hex-WKB STBox, tpoint = hex-WKB tgeopoint. + * All predicates return Boolean (null if either input is null or invalid). + */ +public final class TPointSTBoxOpsUDFs { + + private TPointSTBoxOpsUDFs() {} + + // ------------------------------------------------------------------ + // Helper: deserialize STBox from hex-WKB, check null + // ------------------------------------------------------------------ + + private static Pointer stboxPtr(String hex) { + return hex == null ? null : functions.stbox_from_hexwkb(hex); + } + + private static Pointer tpointPtr(String hex) { + return hex == null ? null : functions.temporal_from_hexwkb(hex); + } + + // ------------------------------------------------------------------ + // STBox × TPoint — spatial direction + // ------------------------------------------------------------------ + + public static final UDF2 stboxLeftTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.left_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverleftTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overleft_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxRightTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.right_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverrightTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overright_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxBelowTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.below_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverbelowTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overbelow_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxAboveTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.above_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOveraboveTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overabove_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxFrontTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.front_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverfrontTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overfront_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxBackTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.back_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverbackTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overback_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + // ------------------------------------------------------------------ + // STBox × TPoint — temporal direction + // ------------------------------------------------------------------ + + public static final UDF2 stboxBeforeTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.before_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverbeforeTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overbefore_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxAfterTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.after_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverafterTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overafter_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + // ------------------------------------------------------------------ + // STBox × TPoint — topological + // ------------------------------------------------------------------ + + public static final UDF2 stboxAdjacentTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.adjacent_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxContainsTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.contains_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxContainedTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.contained_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxOverlapsTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.overlaps_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 stboxSameTpoint = + (sb, tp) -> { + MeosThread.ensureReady(); + Pointer s = stboxPtr(sb); if (s == null) return null; + Pointer t = tpointPtr(tp); if (t == null) { MeosMemory.free(s); return null; } + try { return MeosNative.INSTANCE.same_stbox_tspatial(s, t); } + finally { MeosMemory.free(s, t); } + }; + + // ------------------------------------------------------------------ + // TPoint × STBox — spatial direction + // ------------------------------------------------------------------ + + public static final UDF2 tpointLeftStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.left_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverleftStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overleft_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointRightStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.right_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverrightStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overright_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointBelowStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.below_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverbelowStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overbelow_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointAboveStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.above_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOveraboveStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overabove_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointFrontStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.front_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverfrontStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overfront_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointBackStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.back_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverbackStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overback_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + // ------------------------------------------------------------------ + // TPoint × STBox — temporal direction + // ------------------------------------------------------------------ + + public static final UDF2 tpointBeforeStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.before_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverbeforeStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overbefore_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointAfterStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.after_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverafterStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overafter_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + // ------------------------------------------------------------------ + // TPoint × STBox — topological + // ------------------------------------------------------------------ + + public static final UDF2 tpointAdjacentStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.adjacent_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointContainsStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.contains_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointContainedStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.contained_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointOverlapsStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.overlaps_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 tpointSameStbox = + (tp, sb) -> { + MeosThread.ensureReady(); + Pointer t = tpointPtr(tp); if (t == null) return null; + Pointer s = stboxPtr(sb); if (s == null) { MeosMemory.free(t); return null; } + try { return MeosNative.INSTANCE.same_tspatial_stbox(t, s); } + finally { MeosMemory.free(t, s); } + }; + + // ------------------------------------------------------------------ + // Register all + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // STBox × TPoint — spatial direction + spark.udf().register("stboxLeftTpoint", stboxLeftTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverleftTpoint", stboxOverleftTpoint, DataTypes.BooleanType); + spark.udf().register("stboxRightTpoint", stboxRightTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverrightTpoint", stboxOverrightTpoint, DataTypes.BooleanType); + spark.udf().register("stboxBelowTpoint", stboxBelowTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverbelowTpoint", stboxOverbelowTpoint, DataTypes.BooleanType); + spark.udf().register("stboxAboveTpoint", stboxAboveTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOveraboveTpoint", stboxOveraboveTpoint, DataTypes.BooleanType); + spark.udf().register("stboxFrontTpoint", stboxFrontTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverfrontTpoint", stboxOverfrontTpoint, DataTypes.BooleanType); + spark.udf().register("stboxBackTpoint", stboxBackTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverbackTpoint", stboxOverbackTpoint, DataTypes.BooleanType); + // STBox × TPoint — temporal direction + spark.udf().register("stboxBeforeTpoint", stboxBeforeTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverbeforeTpoint", stboxOverbeforeTpoint, DataTypes.BooleanType); + spark.udf().register("stboxAfterTpoint", stboxAfterTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverafterTpoint", stboxOverafterTpoint, DataTypes.BooleanType); + // STBox × TPoint — topological + spark.udf().register("stboxAdjacentTpoint", stboxAdjacentTpoint, DataTypes.BooleanType); + spark.udf().register("stboxContainsTpoint", stboxContainsTpoint, DataTypes.BooleanType); + spark.udf().register("stboxContainedTpoint", stboxContainedTpoint, DataTypes.BooleanType); + spark.udf().register("stboxOverlapsTpoint", stboxOverlapsTpoint, DataTypes.BooleanType); + spark.udf().register("stboxSameTpoint", stboxSameTpoint, DataTypes.BooleanType); + + // TPoint × STBox — spatial direction + spark.udf().register("tpointLeftStbox", tpointLeftStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverleftStbox", tpointOverleftStbox, DataTypes.BooleanType); + spark.udf().register("tpointRightStbox", tpointRightStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverrightStbox", tpointOverrightStbox, DataTypes.BooleanType); + spark.udf().register("tpointBelowStbox", tpointBelowStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverbelowStbox", tpointOverbelowStbox, DataTypes.BooleanType); + spark.udf().register("tpointAboveStbox", tpointAboveStbox, DataTypes.BooleanType); + spark.udf().register("tpointOveraboveStbox", tpointOveraboveStbox, DataTypes.BooleanType); + spark.udf().register("tpointFrontStbox", tpointFrontStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverfrontStbox", tpointOverfrontStbox, DataTypes.BooleanType); + spark.udf().register("tpointBackStbox", tpointBackStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverbackStbox", tpointOverbackStbox, DataTypes.BooleanType); + // TPoint × STBox — temporal direction + spark.udf().register("tpointBeforeStbox", tpointBeforeStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverbeforeStbox", tpointOverbeforeStbox, DataTypes.BooleanType); + spark.udf().register("tpointAfterStbox", tpointAfterStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverafterStbox", tpointOverafterStbox, DataTypes.BooleanType); + // TPoint × STBox — topological + spark.udf().register("tpointAdjacentStbox", tpointAdjacentStbox, DataTypes.BooleanType); + spark.udf().register("tpointContainsStbox", tpointContainsStbox, DataTypes.BooleanType); + spark.udf().register("tpointContainedStbox", tpointContainedStbox, DataTypes.BooleanType); + spark.udf().register("tpointOverlapsStbox", tpointOverlapsStbox, DataTypes.BooleanType); + spark.udf().register("tpointSameStbox", tpointSameStbox, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFs.java b/src/main/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFs.java new file mode 100644 index 00000000..13b9e247 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFs.java @@ -0,0 +1,308 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for temporal spatial relationships on tpoint. + * + * These UDFs return a tbool (encoded as hex-WKB STRING) that is true at each + * instant where the spatial relationship holds. This complements the "ever" + * predicates in GeoUDFs (eIntersects, eContains, eDwithin) which return a + * scalar Boolean. + * + * Covered relationships: + * tDisjoint — tgeompoint is disjoint from geometry at each instant + * tIntersects — tgeompoint intersects geometry at each instant + * tTouches — tgeompoint touches geometry at each instant + * + * (tContains, tCovers, tDwithin are already provided in GeoAnalyticsUDFs.) + * + * Storage convention: + * tgeompoint → hex-WKB STRING (temporal_as_hexwkb) + * geometry → WKT STRING (geo_from_text with SRID from trip bbox) + * tbool result→ hex-WKB STRING + * + * MEOS function authority: meos/include/meos_geo.h (072_tgeo_tempspatialrels) + */ +public final class TempSpatialRelsUDFs { + + private TempSpatialRelsUDFs() {} + + private static int tripSrid(Pointer tptr) { + Pointer bbox = functions.tspatial_to_stbox(tptr); + if (bbox == null) return 0; + try { + return functions.stbox_srid(bbox); + } finally { + MeosMemory.free(bbox); + } + } + + private static String tempHexOut(Pointer r) { + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } + + // ------------------------------------------------------------------ + // tDisjoint(tpoint STRING, geomWkt STRING) → STRING (tbool hex-WKB) + // + // Returns a tbool that is true at instants where the moving point is + // disjoint from (i.e. does not intersect) the static geometry. + // + // MEOS: tdisjoint_tgeo_geo(Temporal *, GSERIALIZED *) + // restr=false → return full tbool (not restricted to true/false instants) + // ------------------------------------------------------------------ + public static final UDF2 tDisjoint = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.tdisjoint_tgeo_geo(tptr, gptr)); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + // ------------------------------------------------------------------ + // tIntersects(tpoint STRING, geomWkt STRING) → STRING (tbool hex-WKB) + // + // Returns a tbool that is true at instants where the moving point + // intersects the static geometry. + // + // MEOS: tintersects_tgeo_geo(Temporal *, GSERIALIZED *) + // ------------------------------------------------------------------ + public static final UDF2 tIntersects = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.tintersects_tgeo_geo(tptr, gptr)); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + // ------------------------------------------------------------------ + // tTouches(tpoint STRING, geomWkt STRING) → STRING (tbool hex-WKB) + // + // Returns a tbool that is true at instants where the moving point + // touches (shares boundary with) the static geometry. + // + // MEOS: ttouches_tgeo_geo(Temporal *, GSERIALIZED *) + // ------------------------------------------------------------------ + public static final UDF2 tTouches = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.ttouches_tgeo_geo(tptr, gptr)); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + // ------------------------------------------------------------------ + // tDisjointTgeoTgeo(trip1 STRING, trip2 STRING) → STRING (tbool hex-WKB) + // tIntersectsTgeoTgeo(trip1 STRING, trip2 STRING) → STRING + // tTouchesTogeoTgeo(trip1 STRING, trip2 STRING) → STRING + // + // Temporal predicates for two moving objects. + // + // MEOS: tdisjoint_tgeo_tgeo, tintersects_tgeo_tgeo, ttouches_tgeo_tgeo + // ------------------------------------------------------------------ + public static final UDF2 tDisjointTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return tempHexOut(functions.tdisjoint_tgeo_tgeo(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tIntersectsTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return tempHexOut(functions.tintersects_tgeo_tgeo(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tTouchesTogeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return tempHexOut(functions.ttouches_tgeo_tgeo(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // tContainsTgeoGeo(trip STRING, geomWkt STRING) → STRING + // tContainsTgeoTgeo(trip1 STRING, trip2 STRING) → STRING + // + // Note: tContains(geomWkt, trip) already exists in GeoAnalyticsUDFs + // (tcontains_geo_tgeo — container is static). These variants cover + // the case where the moving object is the container. + // + // MEOS: tcontains_tgeo_geo, tcontains_tgeo_tgeo + // ------------------------------------------------------------------ + public static final UDF2 tContainsTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.tcontains_tgeo_geo(tptr, gptr)); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + public static final UDF2 tContainsTgeoTgeo = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p2 == null) return null; + try { + return tempHexOut(functions.tcontains_tgeo_tgeo(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // tCoversTgeoGeo(trip STRING, geomWkt STRING) → STRING + // + // MEOS: tcovers_tgeo_geo + // ------------------------------------------------------------------ + public static final UDF2 tCoversTgeoGeo = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.tcovers_tgeo_geo(tptr, gptr)); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + // ------------------------------------------------------------------ + // tDwithinTgeoGeo(trip STRING, geomWkt STRING, dist DOUBLE) → STRING + // + // MEOS: tdwithin_tgeo_geo + // ------------------------------------------------------------------ + public static final UDF3 tDwithinTgeoGeo = + (trip, geomWkt, dist) -> { + if (trip == null || geomWkt == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + int srid = tripSrid(tptr); + Pointer gptr = functions.geo_from_text(geomWkt, srid); + if (gptr == null) return null; + try { + return tempHexOut(functions.tdwithin_tgeo_geo(tptr, gptr, dist.doubleValue())); + } finally { MeosMemory.free(gptr); } + } finally { MeosMemory.free(tptr); } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + spark.udf().register("tDisjoint", tDisjoint, DataTypes.StringType); + spark.udf().register("tIntersects", tIntersects, DataTypes.StringType); + spark.udf().register("tTouches", tTouches, DataTypes.StringType); + spark.udf().register("tDisjointTgeoTgeo", tDisjointTgeoTgeo, DataTypes.StringType); + spark.udf().register("tIntersectsTgeoTgeo", tIntersectsTgeoTgeo, DataTypes.StringType); + spark.udf().register("tTouchesTogeoTgeo", tTouchesTogeoTgeo, DataTypes.StringType); + spark.udf().register("tContainsTgeoGeo", tContainsTgeoGeo, DataTypes.StringType); + spark.udf().register("tContainsTgeoTgeo", tContainsTgeoTgeo, DataTypes.StringType); + spark.udf().register("tCoversTgeoGeo", tCoversTgeoGeo, DataTypes.StringType); + spark.udf().register("tDwithinTgeoGeo", tDwithinTgeoGeo, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/h3/Th3IndexUDFs.java b/src/main/java/org/mobilitydb/spark/h3/Th3IndexUDFs.java new file mode 100644 index 00000000..34756932 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/h3/Th3IndexUDFs.java @@ -0,0 +1,1126 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.h3; + +import functions.functions; +import jnr.ffi.Pointer; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.api.java.UDF5; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; + +/** + * Spark SQL UDFs for the temporal H3 index type (th3index) and its supporting + * static h3index / h3indexset surfaces. Mirrors the public C API at + * + * meos/include/meos_h3.h — th3index temporal type (66 fns) + * meos/include/h3/h3index.h — static h3index scalar ops (10 fns) + * meos/include/h3/h3index_sets.h — h3indexset (Set of cells) ops (9 fns) + * + * The class targets 100% parity with the public h3 API. Sections below + * mirror the layout of meos_h3.h for traceability. + * + * Storage convention: + * tgeompoint / tgeogpoint / th3index → hex-WKB STRING (Temporal hex-WKB) + * H3Index → BIGINT (uint64 fits in Java long) + * h3indexset (Set of H3Index) → hex-WKB STRING (Set hex-WKB) + * TimestampTz → java.sql.Timestamp / String + * interpType → INTEGER (NONE=0, DISCRETE=1, + * STEP=2, LINEAR=3) + * + * Memory management: every native Pointer allocated by MEOS must be freed + * via MeosMemory.free() in a finally block. Pointers returned by JNR- + * allocated output buffers (the *_value_at_timestamptz / *_value_n forms) + * have a JNR Cleaner attached and must NOT be MeosMemory.free'd — see + * feedback_jnr_allocated_buffer_nofree.md. + */ +public final class Th3IndexUDFs { + + private Th3IndexUDFs() {} + + // ================================================================== + // Helpers — keep the per-UDF code concise + // ================================================================== + + /** Default H3 resolution for the BerlinMOD prefilter — ~1.2 km cells. */ + public static final int DEFAULT_RESOLUTION = 7; + + private static final DateTimeFormatter PG_FMT = + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssXXX"); + + /** Spark Timestamp / String → MEOS OffsetDateTime via pg_timestamptz_in. */ + private static OffsetDateTime parseTs(Object arg) { + if (arg == null) return null; + if (arg instanceof java.sql.Timestamp) { + return functions.pg_timestamptz_in( + ((java.sql.Timestamp) arg).toInstant().atOffset(ZoneOffset.UTC).format(PG_FMT), -1); + } + return functions.pg_timestamptz_in(arg.toString().trim(), -1); + } + + /** Convert a Number arg (Spark sends Int / Long / BigDecimal) to int. */ + private static int toInt(Number n) { return n == null ? 0 : n.intValue(); } + + /** Serialise a Temporal* result as hex-WKB and free the input pointer. */ + private static String tempHex(Pointer t) { + if (t == null) return null; + try { return functions.temporal_as_hexwkb(t, (byte) 0); } + finally { MeosMemory.free(t); } + } + + /** Serialise a Set* result as hex-WKB and free the input pointer. */ + private static String setHex(Pointer s) { + if (s == null) return null; + try { return functions.set_as_hexwkb(s, (byte) 0); } + finally { MeosMemory.free(s); } + } + + // ================================================================== + // Static h3index SQL type — meos/include/h3/h3index.h + // ================================================================== + + public static final UDF1 h3IndexFromText = (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + return functions.h3index_in(s); + }; + + public static final UDF1 h3IndexAsText = (cell) -> { + if (cell == null) return null; + MeosThread.ensureReady(); + return functions.h3index_out(cell); + }; + + public static final UDF1 h3IndexParse = (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + return functions.h3index_parse(s); + }; + + public static final UDF1 h3IndexToString = (cell) -> { + if (cell == null) return null; + MeosThread.ensureReady(); + return functions.h3index_to_string(cell); + }; + + public static final UDF2 h3IndexEq = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_eq(a, b); + }; + + public static final UDF2 h3IndexNe = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_ne(a, b); + }; + + public static final UDF2 h3IndexLt = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_lt(a, b); + }; + + public static final UDF2 h3IndexLe = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_le(a, b); + }; + + public static final UDF2 h3IndexGt = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_gt(a, b); + }; + + public static final UDF2 h3IndexGe = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_ge(a, b); + }; + + public static final UDF2 h3IndexCmp = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + return functions.h3index_cmp(a, b); + }; + + public static final UDF1 h3IndexHash = (cell) -> { + if (cell == null) return null; + MeosThread.ensureReady(); + return (long) functions.h3index_hash(cell); + }; + + // ================================================================== + // h3indexset (Set of H3Index) — meos/include/h3/h3index_sets.h + // All return Set* serialised as hex-WKB STRING. + // ================================================================== + + public static final UDF2 h3GridDisk = (origin, k) -> { + if (origin == null || k == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_grid_disk(origin, k)); + }; + + public static final UDF2 h3GridRing = (origin, k) -> { + if (origin == null || k == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_grid_ring(origin, k)); + }; + + public static final UDF2 h3GridPathCells = (start, end) -> { + if (start == null || end == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_grid_path_cells(start, end)); + }; + + public static final UDF2 h3CellToChildren = (origin, childRes) -> { + if (origin == null || childRes == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_cell_to_children(origin, childRes)); + }; + + public static final UDF1 h3CompactCells = (cellsHex) -> { + if (cellsHex == null) return null; + MeosThread.ensureReady(); + Pointer in = functions.set_from_hexwkb(cellsHex); + if (in == null) return null; + try { return setHex(functions.h3_compact_cells(in)); } + finally { MeosMemory.free(in); } + }; + + public static final UDF2 h3UncompactCells = (cellsHex, res) -> { + if (cellsHex == null || res == null) return null; + MeosThread.ensureReady(); + Pointer in = functions.set_from_hexwkb(cellsHex); + if (in == null) return null; + try { return setHex(functions.h3_uncompact_cells(in, res)); } + finally { MeosMemory.free(in); } + }; + + public static final UDF1 h3OriginToDirectedEdges = (origin) -> { + if (origin == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_origin_to_directed_edges(origin)); + }; + + public static final UDF1 h3CellToVertexes = (cell) -> { + if (cell == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_cell_to_vertexes(cell)); + }; + + public static final UDF1 h3GetIcosahedronFaces = (cell) -> { + if (cell == null) return null; + MeosThread.ensureReady(); + return setHex(functions.h3_get_icosahedron_faces(cell)); + }; + + // ================================================================== + // th3index input / output — meos_h3.h "Type inheritance" + // ================================================================== + + public static final UDF1 th3IndexFromText = (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + return tempHex(functions.th3index_in(s)); + }; + + public static final UDF1 th3IndexInstFromText = (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.th3indexinst_in(s); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 th3IndexSeqFromText = (s, interp) -> { + if (s == null || interp == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.th3indexseq_in(s, interp); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 th3IndexSeqSetFromText = (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.th3indexseqset_in(s); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + // ================================================================== + // th3index constructors — meos_h3.h "Constructors" + // + // The instant + scalar make() forms are scalar-arg. The seq / seqset + // forms accept arrays which are not exposed here — callers can compose + // by parsing instants and concatenating via temporal_merge / temporal_seq. + // ================================================================== + + public static final UDF2 th3IndexMake = (cell, tsArg) -> { + if (cell == null || tsArg == null) return null; + MeosThread.ensureReady(); + OffsetDateTime t = parseTs(tsArg); + return tempHex(functions.th3index_make(cell, t)); + }; + + public static final UDF2 th3IndexInstMake = (cell, tsArg) -> { + if (cell == null || tsArg == null) return null; + MeosThread.ensureReady(); + OffsetDateTime t = parseTs(tsArg); + Pointer p = functions.th3indexinst_make(cell, t); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + /** + * th3indexseq_make(values[], times[], count, lower_inc, upper_inc) → TSequence hex-WKB. + * + * Spark passes parallel ARRAY + ARRAY; we marshal both + * to JNR-FFI native arrays and call the MEOS constructor. The two arrays + * must have the same length; count is inferred from the value array. + */ + public static final UDF5 th3IndexSeqMake = + (values, timestamps, lowerInc, upperInc, ignored) -> { + if (values == null || timestamps == null) return null; + if (values.length != timestamps.length) return null; + MeosThread.ensureReady(); + OffsetDateTime[] times = new OffsetDateTime[timestamps.length]; + for (int i = 0; i < timestamps.length; i++) times[i] = parseTs(timestamps[i]); + Pointer p = functions.th3indexseq_make( + values, times, values.length, + lowerInc != null && lowerInc, + upperInc != null && upperInc); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + /** + * th3indexseqset_make(sequences[]) → TSequenceSet hex-WKB. + * + * Spark passes ARRAY of hex-WKB TSequence; we parse each into a + * native Pointer, hand the array to the MEOS constructor, free the + * intermediate pointers. + */ + public static final UDF1 th3IndexSeqSetMake = (sequencesHex) -> { + if (sequencesHex == null) return null; + MeosThread.ensureReady(); + Pointer[] seqs = new Pointer[sequencesHex.length]; + try { + for (int i = 0; i < sequencesHex.length; i++) { + seqs[i] = functions.temporal_from_hexwkb(sequencesHex[i]); + if (seqs[i] == null) return null; + } + Pointer p = functions.th3indexseqset_make(seqs, seqs.length); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + } finally { + for (Pointer s : seqs) if (s != null) MeosMemory.free(s); + } + }; + + // ================================================================== + // Accessors — meos_h3.h "Accessors" + // ================================================================== + + public static final UDF1 th3IndexStartValue = (th3idx) -> { + if (th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return functions.th3index_start_value(t); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexEndValue = (th3idx) -> { + if (th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return functions.th3index_end_value(t); } + finally { MeosMemory.free(t); } + }; + + /** + * th3index_values(th3idx) → ARRAY<LONG> (all distinct H3 cells in the trip's path). + * + * MEOS signature: H3Index *th3index_values(const Temporal *temp, int *count); + * the H3Index buffer is owned by MEOS and must be freed by the caller. + */ + public static final UDF1 th3IndexValues = (th3idx) -> { + if (th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return functions.th3index_values(t); } + finally { MeosMemory.free(t); } + }; + + /** + * th3index_value_n(th3idx, n) → H3Index. + * MEOS signature: bool th3index_value_n(const Temporal *, int n, H3Index *result). + * JMEOS auto-allocates the H3Index output buffer; we read the value and + * let the JNR Cleaner reclaim it (do NOT MeosMemory.free). + */ + public static final UDF2 th3IndexValueN = (th3idx, n) -> { + if (th3idx == null || n == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { + Pointer result = functions.th3index_value_n(t, n); + return result == null ? null : result.getLong(0); + } finally { + MeosMemory.free(t); + } + }; + + /** + * th3index_value_at_timestamptz(th3idx, ts, strict) → H3Index. + * MEOS signature: bool th3index_value_at_timestamptz(const Temporal *, + * TimestampTz, bool, H3Index*). + * JMEOS auto-allocates the output; treat the returned Pointer as a JNR + * buffer per feedback_jnr_allocated_buffer_nofree.md. + */ + public static final UDF3 th3IndexValueAtTimestamp = + (th3idx, tsArg, strict) -> { + if (th3idx == null || tsArg == null) return null; + MeosThread.ensureReady(); + OffsetDateTime ts = parseTs(tsArg); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { + Pointer result = functions.th3index_value_at_timestamptz( + t, ts, strict != null && strict); + return result == null ? null : result.getLong(0); + } finally { + MeosMemory.free(t); + } + }; + + // ================================================================== + // MEOS-level conversions — meos_h3.h "MEOS-level conversions" + // ================================================================== + + public static final UDF1 tbigintToTh3Index = (tbi) -> { + if (tbi == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(tbi); + if (t == null) return null; + try { return tempHex(functions.tbigint_to_th3index(t)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexToTbigint = (th3idx) -> { + if (th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return tempHex(functions.th3index_to_tbigint(t)); } + finally { MeosMemory.free(t); } + }; + + // ================================================================== + // Ever / always comparison operators — meos_h3.h + // ================================================================== + + public static final UDF2 everEqH3IndexTh3Index = + (cell, th3idx) -> evCmp(cell, th3idx, true, "ever_eq"); + public static final UDF2 everEqTh3IndexH3Index = + (th3idx, cell) -> evCmp(cell, th3idx, true, "ever_eq_t"); + public static final UDF2 everNeH3IndexTh3Index = + (cell, th3idx) -> evCmp(cell, th3idx, true, "ever_ne"); + public static final UDF2 everNeTh3IndexH3Index = + (th3idx, cell) -> evCmp(cell, th3idx, true, "ever_ne_t"); + public static final UDF2 alwaysEqH3IndexTh3Index = + (cell, th3idx) -> evCmp(cell, th3idx, false, "always_eq"); + public static final UDF2 alwaysEqTh3IndexH3Index = + (th3idx, cell) -> evCmp(cell, th3idx, false, "always_eq_t"); + public static final UDF2 alwaysNeH3IndexTh3Index = + (cell, th3idx) -> evCmp(cell, th3idx, false, "always_ne"); + public static final UDF2 alwaysNeTh3IndexH3Index = + (th3idx, cell) -> evCmp(cell, th3idx, false, "always_ne_t"); + + /** Dispatch helper for the 8 ever/always × eq/ne × cell-side variants. */ + private static Boolean evCmp(Long cell, String th3idx, boolean ever, String op) { + if (cell == null || th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { + int r; + switch (op) { + case "ever_eq": r = functions.ever_eq_h3index_th3index(cell, t); break; + case "ever_eq_t": r = functions.ever_eq_th3index_h3index(t, cell); break; + case "ever_ne": r = functions.ever_ne_h3index_th3index(cell, t); break; + case "ever_ne_t": r = functions.ever_ne_th3index_h3index(t, cell); break; + case "always_eq": r = functions.always_eq_h3index_th3index(cell, t); break; + case "always_eq_t": r = functions.always_eq_th3index_h3index(t, cell); break; + case "always_ne": r = functions.always_ne_h3index_th3index(cell, t); break; + case "always_ne_t": r = functions.always_ne_th3index_h3index(t, cell); break; + default: throw new IllegalStateException(op); + } + return r < 0 ? null : r == 1; + } finally { + MeosMemory.free(t); + } + } + + public static final UDF2 everEqTh3IndexTh3Index = + (a, b) -> ttCmp(a, b, "ever_eq"); + public static final UDF2 everNeTh3IndexTh3Index = + (a, b) -> ttCmp(a, b, "ever_ne"); + public static final UDF2 alwaysEqTh3IndexTh3Index = + (a, b) -> ttCmp(a, b, "always_eq"); + public static final UDF2 alwaysNeTh3IndexTh3Index = + (a, b) -> ttCmp(a, b, "always_ne"); + + /** Dispatch helper for the 4 trip×trip ever/always × eq/ne variants. */ + private static Boolean ttCmp(String a, String b, String op) { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { + int r; + switch (op) { + case "ever_eq": r = functions.ever_eq_th3index_th3index(p, q); break; + case "ever_ne": r = functions.ever_ne_th3index_th3index(p, q); break; + case "always_eq": r = functions.always_eq_th3index_th3index(p, q); break; + case "always_ne": r = functions.always_ne_th3index_th3index(p, q); break; + default: throw new IllegalStateException(op); + } + return r < 0 ? null : r == 1; + } finally { + MeosMemory.free(q); + } + } finally { + MeosMemory.free(p); + } + } + + // ================================================================== + // Temporal comparison operators — meos_h3.h + // Return tbool serialised as hex-WKB. + // ================================================================== + + public static final UDF2 teqH3IndexTh3Index = (cell, th3idx) -> { + if (cell == null || th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return tempHex(functions.teq_h3index_th3index(cell, t)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 teqTh3IndexH3Index = (th3idx, cell) -> { + if (th3idx == null || cell == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return tempHex(functions.teq_th3index_h3index(t, cell)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 teqTh3IndexTh3Index = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.teq_th3index_th3index(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 tneH3IndexTh3Index = (cell, th3idx) -> { + if (cell == null || th3idx == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return tempHex(functions.tne_h3index_th3index(cell, t)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 tneTh3IndexH3Index = (th3idx, cell) -> { + if (th3idx == null || cell == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { return tempHex(functions.tne_th3index_h3index(t, cell)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 tneTh3IndexTh3Index = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.tne_th3index_th3index(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + // ================================================================== + // Inspection — meos_h3.h + // All return Temporal* (tint or tbool) serialised as hex-WKB. + // ================================================================== + + public static final UDF1 th3IndexGetResolution = + (h) -> tempUnary(h, "get_resolution"); + public static final UDF1 th3IndexGetBaseCellNumber = + (h) -> tempUnary(h, "get_base_cell_number"); + public static final UDF1 th3IndexIsValidCell = + (h) -> tempUnary(h, "is_valid_cell"); + public static final UDF1 th3IndexIsResClassIii = + (h) -> tempUnary(h, "is_res_class_iii"); + public static final UDF1 th3IndexIsPentagon = + (h) -> tempUnary(h, "is_pentagon"); + + /** Dispatch helper for unary Temporal* → Temporal* th3index inspections. */ + private static String tempUnary(String h, String op) { + if (h == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { + Pointer r; + switch (op) { + case "get_resolution": r = functions.th3index_get_resolution(t); break; + case "get_base_cell_number":r = functions.th3index_get_base_cell_number(t); break; + case "is_valid_cell": r = functions.th3index_is_valid_cell(t); break; + case "is_res_class_iii": r = functions.th3index_is_res_class_iii(t); break; + case "is_pentagon": r = functions.th3index_is_pentagon(t); break; + case "cell_to_parent_next": r = functions.th3index_cell_to_parent_next(t); break; + case "cell_to_center_child_next": + r = functions.th3index_cell_to_center_child_next(t); break; + case "is_valid_directed_edge": + r = functions.th3index_is_valid_directed_edge(t); break; + case "get_directed_edge_origin": + r = functions.th3index_get_directed_edge_origin(t); break; + case "get_directed_edge_destination": + r = functions.th3index_get_directed_edge_destination(t); break; + case "directed_edge_to_boundary": + r = functions.th3index_directed_edge_to_boundary(t); break; + case "vertex_to_latlng": r = functions.th3index_vertex_to_latlng(t); break; + case "is_valid_vertex": r = functions.th3index_is_valid_vertex(t); break; + case "to_tgeogpoint": r = functions.th3index_to_tgeogpoint(t); break; + case "to_tgeompoint": r = functions.th3index_to_tgeompoint(t); break; + case "cell_to_boundary": r = functions.th3index_cell_to_boundary(t); break; + default: throw new IllegalStateException(op); + } + return tempHex(r); + } finally { + MeosMemory.free(t); + } + } + + // ================================================================== + // Hierarchy — meos_h3.h + // ================================================================== + + public static final UDF2 th3IndexCellToParent = (h, res) -> { + if (h == null || res == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_cell_to_parent(t, res)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexCellToParentNext = + (h) -> tempUnary(h, "cell_to_parent_next"); + + public static final UDF2 th3IndexCellToCenterChild = (h, res) -> { + if (h == null || res == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_cell_to_center_child(t, res)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexCellToCenterChildNext = + (h) -> tempUnary(h, "cell_to_center_child_next"); + + public static final UDF2 th3IndexCellToChildPos = (h, parentRes) -> { + if (h == null || parentRes == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_cell_to_child_pos(t, parentRes)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF3 th3IndexChildPosToCell = + (childPos, parent, childRes) -> { + if (childPos == null || parent == null || childRes == null) return null; + MeosThread.ensureReady(); + Pointer cp = functions.temporal_from_hexwkb(childPos); + if (cp == null) return null; + try { + Pointer pa = functions.temporal_from_hexwkb(parent); + if (pa == null) return null; + try { return tempHex(functions.th3index_child_pos_to_cell(cp, pa, childRes)); } + finally { MeosMemory.free(pa); } + } finally { + MeosMemory.free(cp); + } + }; + + // ================================================================== + // Lat/Lng conversion — meos_h3.h + // ================================================================== + + public static final UDF2 tgeogpointToTh3Index = (h, res) -> { + if (h == null || res == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.tgeogpoint_to_th3index(t, res)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 tgeompointToTh3Index = (h, res) -> { + if (h == null || res == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.tgeompoint_to_th3index(t, res)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexToTgeogpoint = + (h) -> tempUnary(h, "to_tgeogpoint"); + public static final UDF1 th3IndexToTgeompoint = + (h) -> tempUnary(h, "to_tgeompoint"); + public static final UDF1 th3IndexCellToBoundary = + (h) -> tempUnary(h, "cell_to_boundary"); + + /** + * geomToH3Cell(geomWkt, resolution) → H3Index. + * + * Composed from the public API: a static POINT geometry is wrapped in a + * single-instant tgeompoint, converted to th3index, and the start value is + * extracted as the H3Index. Returns NULL for non-POINT geometries (the + * prefilter consumer treats NULL as "no prefilter for this row"). Polygon + * coverage requires the upstream geo_to_h3index_set helper (separate PR). + */ + public static final UDF2 geomToH3Cell = + (geomWkt, resolution) -> { + if (geomWkt == null || resolution == null) return null; + MeosThread.ensureReady(); + Pointer gs = functions.geo_from_text(geomWkt, 0); + if (gs == null) return null; + try { + Pointer inst = functions.tpointinst_make(gs, 0L); + if (inst == null) return null; + try { + Pointer th3 = functions.tgeompoint_to_th3index(inst, resolution); + if (th3 == null) return null; + try { return functions.th3index_start_value(th3); } + finally { MeosMemory.free(th3); } + } finally { + MeosMemory.free(inst); + } + } finally { + MeosMemory.free(gs); + } + }; + + /** + * geoToH3IndexSet(geomWkt, resolution) → STRING (hex-WKB h3indexset). + * + * Cross-platform spatial prefilter source for polygon-side queries + * (BerlinMOD Q2 et al.). Handles every WKT geometry type — POINT, + * LINESTRING, POLYGON, MULTI*, GEOMETRYCOLLECTION — via the public + * MEOS kernel geo_to_h3index_set (MobilityDB PR #938). + */ + public static final UDF2 geoToH3IndexSet = + (geomWkt, resolution) -> { + if (geomWkt == null || resolution == null) return null; + MeosThread.ensureReady(); + Pointer gs = functions.geo_from_text(geomWkt, 0); + if (gs == null) return null; + try { + Pointer set = functions.geo_to_h3index_set(gs, resolution); + return setHex(set); + } finally { + MeosMemory.free(gs); + } + }; + + /** + * everIntersectsH3IndexSetTh3Index(cellSetHex, th3idx) → BOOLEAN. + * + * Returns TRUE iff the trip's th3index sequence ever lies in any cell + * of the candidate set. Pair with geoToH3IndexSet to prefilter + * polygon-side cross-join queries. Wraps + * ever_eq_anyof_h3indexset_th3index (MobilityDB PR #938). + */ + public static final UDF2 everIntersectsH3IndexSetTh3Index = + (cellSetHex, th3idx) -> { + if (cellSetHex == null || th3idx == null) return null; + MeosThread.ensureReady(); + Pointer cells = functions.set_from_hexwkb(cellSetHex); + if (cells == null) return null; + try { + Pointer t = functions.temporal_from_hexwkb(th3idx); + if (t == null) return null; + try { + int r = functions.ever_eq_anyof_h3indexset_th3index(cells, t); + return r < 0 ? null : r == 1; + } finally { + MeosMemory.free(t); + } + } finally { + MeosMemory.free(cells); + } + }; + + // ================================================================== + // Directed edges — meos_h3.h + // ================================================================== + + public static final UDF2 th3IndexAreNeighborCells = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.th3index_are_neighbor_cells(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 th3IndexCellsToDirectedEdge = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.th3index_cells_to_directed_edge(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 th3IndexIsValidDirectedEdge = + (h) -> tempUnary(h, "is_valid_directed_edge"); + public static final UDF1 th3IndexGetDirectedEdgeOrigin = + (h) -> tempUnary(h, "get_directed_edge_origin"); + public static final UDF1 th3IndexGetDirectedEdgeDestination = + (h) -> tempUnary(h, "get_directed_edge_destination"); + public static final UDF1 th3IndexDirectedEdgeToBoundary = + (h) -> tempUnary(h, "directed_edge_to_boundary"); + + // ================================================================== + // Vertices — meos_h3.h + // ================================================================== + + public static final UDF2 th3IndexCellToVertex = (h, vertexNum) -> { + if (h == null || vertexNum == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_cell_to_vertex(t, vertexNum)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF1 th3IndexVertexToLatlng = + (h) -> tempUnary(h, "vertex_to_latlng"); + public static final UDF1 th3IndexIsValidVertex = + (h) -> tempUnary(h, "is_valid_vertex"); + + // ================================================================== + // Grid traversal — meos_h3.h + // ================================================================== + + public static final UDF2 th3IndexGridDistance = (a, b) -> { + if (a == null || b == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.th3index_grid_distance(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 th3IndexCellToLocalIj = (origin, cell) -> { + if (origin == null || cell == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(origin); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(cell); + if (q == null) return null; + try { return tempHex(functions.th3index_cell_to_local_ij(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 th3IndexLocalIjToCell = (origin, coord) -> { + if (origin == null || coord == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(origin); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(coord); + if (q == null) return null; + try { return tempHex(functions.th3index_local_ij_to_cell(p, q)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + // ================================================================== + // Metrics — meos_h3.h + // ================================================================== + + public static final UDF2 th3IndexCellArea = (h, unit) -> { + if (h == null || unit == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_cell_area(t, unit)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF2 th3IndexEdgeLength = (h, unit) -> { + if (h == null || unit == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(h); + if (t == null) return null; + try { return tempHex(functions.th3index_edge_length(t, unit)); } + finally { MeosMemory.free(t); } + }; + + public static final UDF3 tgeogpointGreatCircleDistance = + (a, b, unit) -> { + if (a == null || b == null || unit == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(a); + if (p == null) return null; + try { + Pointer q = functions.temporal_from_hexwkb(b); + if (q == null) return null; + try { return tempHex(functions.tgeogpoint_great_circle_distance(p, q, unit)); } + finally { MeosMemory.free(q); } + } finally { MeosMemory.free(p); } + }; + + // ================================================================== + // Registration — exposes every UDF above to Spark SQL. + // ================================================================== + + public static void registerAll(SparkSession spark) { + // Static h3index ops + spark.udf().register("h3IndexFromText", h3IndexFromText, DataTypes.LongType); + spark.udf().register("h3IndexAsText", h3IndexAsText, DataTypes.StringType); + spark.udf().register("h3IndexParse", h3IndexParse, DataTypes.LongType); + spark.udf().register("h3IndexToString", h3IndexToString, DataTypes.StringType); + spark.udf().register("h3IndexEq", h3IndexEq, DataTypes.BooleanType); + spark.udf().register("h3IndexNe", h3IndexNe, DataTypes.BooleanType); + spark.udf().register("h3IndexLt", h3IndexLt, DataTypes.BooleanType); + spark.udf().register("h3IndexLe", h3IndexLe, DataTypes.BooleanType); + spark.udf().register("h3IndexGt", h3IndexGt, DataTypes.BooleanType); + spark.udf().register("h3IndexGe", h3IndexGe, DataTypes.BooleanType); + spark.udf().register("h3IndexCmp", h3IndexCmp, DataTypes.IntegerType); + spark.udf().register("h3IndexHash", h3IndexHash, DataTypes.LongType); + + // h3indexset (Set ops) + spark.udf().register("h3GridDisk", h3GridDisk, DataTypes.StringType); + spark.udf().register("h3GridRing", h3GridRing, DataTypes.StringType); + spark.udf().register("h3GridPathCells", h3GridPathCells, DataTypes.StringType); + spark.udf().register("h3CellToChildren", h3CellToChildren, DataTypes.StringType); + spark.udf().register("h3CompactCells", h3CompactCells, DataTypes.StringType); + spark.udf().register("h3UncompactCells", h3UncompactCells, DataTypes.StringType); + spark.udf().register("h3OriginToDirectedEdges", + h3OriginToDirectedEdges, DataTypes.StringType); + spark.udf().register("h3CellToVertexes", h3CellToVertexes, DataTypes.StringType); + spark.udf().register("h3GetIcosahedronFaces", + h3GetIcosahedronFaces, DataTypes.StringType); + + // th3index I/O + constructors + spark.udf().register("th3IndexFromText", th3IndexFromText, DataTypes.StringType); + spark.udf().register("th3IndexInstFromText", th3IndexInstFromText, DataTypes.StringType); + spark.udf().register("th3IndexSeqFromText", th3IndexSeqFromText, DataTypes.StringType); + spark.udf().register("th3IndexSeqSetFromText", th3IndexSeqSetFromText, DataTypes.StringType); + spark.udf().register("th3IndexMake", th3IndexMake, DataTypes.StringType); + spark.udf().register("th3IndexInstMake", th3IndexInstMake, DataTypes.StringType); + spark.udf().register("th3IndexSeqMake", th3IndexSeqMake, DataTypes.StringType); + spark.udf().register("th3IndexSeqSetMake", th3IndexSeqSetMake, DataTypes.StringType); + + // Accessors + spark.udf().register("th3IndexStartValue", th3IndexStartValue, + DataTypes.LongType); + spark.udf().register("th3IndexEndValue", th3IndexEndValue, + DataTypes.LongType); + spark.udf().register("th3IndexValues", th3IndexValues, + DataTypes.createArrayType(DataTypes.LongType)); + spark.udf().register("th3IndexValueN", th3IndexValueN, + DataTypes.LongType); + spark.udf().register("th3IndexValueAtTimestamp", th3IndexValueAtTimestamp, + DataTypes.LongType); + + // Conversions + spark.udf().register("tbigintToTh3Index", tbigintToTh3Index, DataTypes.StringType); + spark.udf().register("th3IndexToTbigint", th3IndexToTbigint, DataTypes.StringType); + + // Ever / always (cell-side variants) + spark.udf().register("everEqH3IndexTh3Index", everEqH3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("everEqTh3IndexH3Index", everEqTh3IndexH3Index, + DataTypes.BooleanType); + spark.udf().register("everNeH3IndexTh3Index", everNeH3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("everNeTh3IndexH3Index", everNeTh3IndexH3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysEqH3IndexTh3Index", alwaysEqH3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysEqTh3IndexH3Index", alwaysEqTh3IndexH3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysNeH3IndexTh3Index", alwaysNeH3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysNeTh3IndexH3Index", alwaysNeTh3IndexH3Index, + DataTypes.BooleanType); + + // Ever / always (trip × trip variants) + spark.udf().register("everEqTh3IndexTh3Index", everEqTh3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("everNeTh3IndexTh3Index", everNeTh3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysEqTh3IndexTh3Index", alwaysEqTh3IndexTh3Index, + DataTypes.BooleanType); + spark.udf().register("alwaysNeTh3IndexTh3Index", alwaysNeTh3IndexTh3Index, + DataTypes.BooleanType); + + // Temporal comparisons + spark.udf().register("teqH3IndexTh3Index", teqH3IndexTh3Index, DataTypes.StringType); + spark.udf().register("teqTh3IndexH3Index", teqTh3IndexH3Index, DataTypes.StringType); + spark.udf().register("teqTh3IndexTh3Index", teqTh3IndexTh3Index, DataTypes.StringType); + spark.udf().register("tneH3IndexTh3Index", tneH3IndexTh3Index, DataTypes.StringType); + spark.udf().register("tneTh3IndexH3Index", tneTh3IndexH3Index, DataTypes.StringType); + spark.udf().register("tneTh3IndexTh3Index", tneTh3IndexTh3Index, DataTypes.StringType); + + // Inspection + spark.udf().register("th3IndexGetResolution", th3IndexGetResolution, + DataTypes.StringType); + spark.udf().register("th3IndexGetBaseCellNumber", th3IndexGetBaseCellNumber, + DataTypes.StringType); + spark.udf().register("th3IndexIsValidCell", th3IndexIsValidCell, + DataTypes.StringType); + spark.udf().register("th3IndexIsResClassIii", th3IndexIsResClassIii, + DataTypes.StringType); + spark.udf().register("th3IndexIsPentagon", th3IndexIsPentagon, + DataTypes.StringType); + + // Hierarchy + spark.udf().register("th3IndexCellToParent", th3IndexCellToParent, + DataTypes.StringType); + spark.udf().register("th3IndexCellToParentNext", th3IndexCellToParentNext, + DataTypes.StringType); + spark.udf().register("th3IndexCellToCenterChild", th3IndexCellToCenterChild, + DataTypes.StringType); + spark.udf().register("th3IndexCellToCenterChildNext", th3IndexCellToCenterChildNext, + DataTypes.StringType); + spark.udf().register("th3IndexCellToChildPos", th3IndexCellToChildPos, + DataTypes.StringType); + spark.udf().register("th3IndexChildPosToCell", th3IndexChildPosToCell, + DataTypes.StringType); + + // Lat/Lng conversion + spark.udf().register("tgeogpointToTh3Index", tgeogpointToTh3Index, DataTypes.StringType); + spark.udf().register("tgeompointToTh3Index", tgeompointToTh3Index, DataTypes.StringType); + spark.udf().register("th3IndexToTgeogpoint", th3IndexToTgeogpoint, DataTypes.StringType); + spark.udf().register("th3IndexToTgeompoint", th3IndexToTgeompoint, DataTypes.StringType); + spark.udf().register("th3IndexCellToBoundary", th3IndexCellToBoundary, DataTypes.StringType); + spark.udf().register("geomToH3Cell", geomToH3Cell, DataTypes.LongType); + spark.udf().register("geoToH3IndexSet", geoToH3IndexSet, DataTypes.StringType); + spark.udf().register("everIntersectsH3IndexSetTh3Index", + everIntersectsH3IndexSetTh3Index, DataTypes.BooleanType); + + // Directed edges + spark.udf().register("th3IndexAreNeighborCells", th3IndexAreNeighborCells, + DataTypes.StringType); + spark.udf().register("th3IndexCellsToDirectedEdge", th3IndexCellsToDirectedEdge, + DataTypes.StringType); + spark.udf().register("th3IndexIsValidDirectedEdge", th3IndexIsValidDirectedEdge, + DataTypes.StringType); + spark.udf().register("th3IndexGetDirectedEdgeOrigin", th3IndexGetDirectedEdgeOrigin, + DataTypes.StringType); + spark.udf().register("th3IndexGetDirectedEdgeDestination", + th3IndexGetDirectedEdgeDestination, DataTypes.StringType); + spark.udf().register("th3IndexDirectedEdgeToBoundary", th3IndexDirectedEdgeToBoundary, + DataTypes.StringType); + + // Vertices + spark.udf().register("th3IndexCellToVertex", th3IndexCellToVertex, DataTypes.StringType); + spark.udf().register("th3IndexVertexToLatlng", th3IndexVertexToLatlng, DataTypes.StringType); + spark.udf().register("th3IndexIsValidVertex", th3IndexIsValidVertex, DataTypes.StringType); + + // Grid traversal + spark.udf().register("th3IndexGridDistance", th3IndexGridDistance, DataTypes.StringType); + spark.udf().register("th3IndexCellToLocalIj", th3IndexCellToLocalIj, DataTypes.StringType); + spark.udf().register("th3IndexLocalIjToCell", th3IndexLocalIjToCell, DataTypes.StringType); + + // Metrics + spark.udf().register("th3IndexCellArea", th3IndexCellArea, + DataTypes.StringType); + spark.udf().register("th3IndexEdgeLength", th3IndexEdgeLength, + DataTypes.StringType); + spark.udf().register("tgeogpointGreatCircleDistance", tgeogpointGreatCircleDistance, + DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/portable/PortableOperatorAliasUDFs.java b/src/main/java/org/mobilitydb/spark/portable/PortableOperatorAliasUDFs.java new file mode 100644 index 00000000..72d1484c --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/portable/PortableOperatorAliasUDFs.java @@ -0,0 +1,166 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.portable; + +import functions.functions; +import jnr.ffi.Pointer; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.mobilitydb.spark.geo.DistanceUDFs; +import org.mobilitydb.spark.temporal.PosOpsUDFs; +import org.mobilitydb.spark.temporal.TemporalBoxOpsUDFs; +import org.mobilitydb.spark.temporal.TemporalCompUDFs; + +/** + * Portable bare-name operator aliases — the cross-engine SQL dialect. + * + *

Single source of truth: {@code MobilityDB/MEOS-API} + * {@code meta/portable-aliases.json#/families} (RFC #920, discussion + * MobilityDB#861, native in MobilityDB#1075). That contract maps 29 SQL + * operator symbols to 29 portable bare function names, type-agnostically, + * so a user learns one reference and assumes every engine behaves + * identically. Spark SQL has no infix-operator extension API, so every + * operator is exposed as its portable bare named function — and + * the bare name, not a type-qualified spelling, is the portable contract. + * + *

Equivalence by construction. Every alias here reuses the + * operator's own existing backing UDF field verbatim (the exact same + * {@code functions.*} MEOS C symbol the typed UDF dispatches to). No + * operator logic is reimplemented; the alias cannot drift from the + * operator because it is the operator's backing. + * + *

Six families, no headline exclusion. The chosen backings are + * the MEOS superclass entrypoints — {@code *_temporal_temporal} (time / + * topology / temporal-comparison), {@code *_tspatial_tspatial} (spatial + * position), {@code tdistance_tgeo_tgeo}, {@code nad_tgeo_*}. libmeos + * dispatches these internally for any temporal value carried in + * the type-erased hex-WKB string, so the four spatial sibling families + * {@code tcbuffer} / {@code tnpoint} / {@code tpose} / {@code trgeometry} + * are covered by construction alongside {@code temporal} and {@code geo} + * — none is excluded. + * + *

{@code left} / {@code right} / {@code overleft} / {@code overright} + * are the only operators whose MEOS symbol differs by argument + * class (the {@code tnumber} value-axis vs. the {@code tspatial} + * X-axis are distinct C operators). A thin runtime classifier + * selects between the two existing backing fields; it contains no + * operator logic, so equivalence by construction still holds. + * + *

Parity is gated by {@code scripts/portable_parity.py} (the same + * prefix logic as {@code MobilityDB/MEOS-API portable_parity.py}): + * 29/29 bare names registered, 0 unbacked. + */ +public final class PortableOperatorAliasUDFs { + + private PortableOperatorAliasUDFs() {} + + /** + * True iff the hex-WKB value is a {@code tnumber} (tint/tfloat): only + * those have a TBox value extent. Under MEOS's no-exit error handler a + * non-tnumber temporal yields a null TBox. Used solely to select which + * existing backing field to delegate to — never to compute a result. + */ + private static boolean isTnumber(String hex) { + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return false; + try { + Pointer box = functions.tnumber_to_tbox(p); + if (box == null) return false; + MeosMemory.free(box); + return true; + } finally { + MeosMemory.free(p); + } + } + + /** + * Bare value/space-axis operator: delegate to the {@code tnumber} + * backing for a tnumber left argument, otherwise to the + * {@code tspatial} backing. Both delegates are the operator's own + * existing backing fields. + */ + private static UDF2 axis( + UDF2 tnumber, + UDF2 tspatial) { + return (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + return isTnumber(s1) ? tnumber.call(s1, s2) : tspatial.call(s1, s2); + }; + } + + public static void registerAll(SparkSession spark) { + // ── topology (&&, @>, <@, -|-) ── superclass *_temporal_temporal, + // all six families ──────────────────────────────────────────── + spark.udf().register("overlaps", TemporalBoxOpsUDFs.temporalOverlapsTemporal, DataTypes.BooleanType); + spark.udf().register("contains", TemporalBoxOpsUDFs.temporalContainsTemporal, DataTypes.BooleanType); + spark.udf().register("contained", TemporalBoxOpsUDFs.temporalContainedTemporal, DataTypes.BooleanType); + spark.udf().register("adjacent", TemporalBoxOpsUDFs.temporalAdjacentTemporal, DataTypes.BooleanType); + + // ── same (~=) ───────────────────────────────────────────────── + spark.udf().register("same", TemporalBoxOpsUDFs.temporalSameTemporal, DataTypes.BooleanType); + + // ── time position (<<#, #>>, &<#, #&>) ── superclass, all six ── + spark.udf().register("before", PosOpsUDFs.temporalBefore, DataTypes.BooleanType); + spark.udf().register("after", PosOpsUDFs.temporalAfter, DataTypes.BooleanType); + spark.udf().register("overbefore", PosOpsUDFs.temporalOverbefore, DataTypes.BooleanType); + spark.udf().register("overafter", PosOpsUDFs.temporalOverafter, DataTypes.BooleanType); + + // ── space X (<<, >>, &<, &>) ── tnumber value-axis OR tspatial ─ + spark.udf().register("left", axis(PosOpsUDFs.tnumberLeft, PosOpsUDFs.tpointLeft), DataTypes.BooleanType); + spark.udf().register("right", axis(PosOpsUDFs.tnumberRight, PosOpsUDFs.tpointRight), DataTypes.BooleanType); + spark.udf().register("overleft", axis(PosOpsUDFs.tnumberOverleft, PosOpsUDFs.tpointOverleft), DataTypes.BooleanType); + spark.udf().register("overright", axis(PosOpsUDFs.tnumberOverright, PosOpsUDFs.tpointOverright), DataTypes.BooleanType); + + // ── space Y (<<|, |>>, &<|, |&>) ── tspatial, all spatial fams ─ + spark.udf().register("below", PosOpsUDFs.tpointBelow, DataTypes.BooleanType); + spark.udf().register("above", PosOpsUDFs.tpointAbove, DataTypes.BooleanType); + spark.udf().register("overbelow", PosOpsUDFs.tpointOverbelow, DataTypes.BooleanType); + spark.udf().register("overabove", PosOpsUDFs.tpointOverabove, DataTypes.BooleanType); + + // ── space Z / 3D (<>, &) ── tspatial ────────────── + spark.udf().register("front", PosOpsUDFs.tpointFront, DataTypes.BooleanType); + spark.udf().register("back", PosOpsUDFs.tpointBack, DataTypes.BooleanType); + spark.udf().register("overfront", PosOpsUDFs.tpointOverfront, DataTypes.BooleanType); + spark.udf().register("overback", PosOpsUDFs.tpointOverback, DataTypes.BooleanType); + + // ── temporal comparison (#=, #<>, #<, #<=, #>, #>=) ── + // superclass t*_temporal_temporal → temporal tbool (hex-WKB) ── + spark.udf().register("teq", TemporalCompUDFs.teqTemporal, DataTypes.StringType); + spark.udf().register("tne", TemporalCompUDFs.tneTemporal, DataTypes.StringType); + spark.udf().register("tlt", TemporalCompUDFs.tltTemporal, DataTypes.StringType); + spark.udf().register("tle", TemporalCompUDFs.tleTemporal, DataTypes.StringType); + spark.udf().register("tgt", TemporalCompUDFs.tgtTemporal, DataTypes.StringType); + spark.udf().register("tge", TemporalCompUDFs.tgeTemporal, DataTypes.StringType); + + // ── distance (<->, |=|) ─────────────────────────────────────── + spark.udf().register("tdistance", DistanceUDFs.tdistanceTgeoTgeo, DataTypes.StringType); + spark.udf().register("nearestApproachDistance", DistanceUDFs.nadTgeoGeo, DataTypes.DoubleType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/AccessorAliasUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/AccessorAliasUDFs.java new file mode 100644 index 00000000..c3a53a5a --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/AccessorAliasUDFs.java @@ -0,0 +1,883 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +import java.util.HexFormat; +import java.util.function.Function; +import java.util.function.ToIntFunction; +import java.util.function.ToLongFunction; +import java.util.function.ToDoubleFunction; + +/** + * Spark SQL UDFs for typed accessor aliases bridging MobilityDB SQL bare + * names (e.g. `intspan_width`, `dates`, `valueSpans`, `tnumberToSpan`) + * to existing JMEOS bindings. + * + * MEOS function authority: meos/include/meos.h + */ +public final class AccessorAliasUDFs { + + private AccessorAliasUDFs() {} + + // ------------------------------------------------------------------ + // Per-type span/spanset width accessors + // ------------------------------------------------------------------ + + public static final UDF1 intspanWidth = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intspan_width(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 bigintspanWidth = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { return functions.bigintspan_width(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 floatspanWidth = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { return functions.floatspan_width(p); } + finally { MeosMemory.free(p); } + }; + + // boundspan param: TRUE = use the span of the union of all components, + // FALSE = sum of individual span widths. + public static final UDF2 intspansetWidth = + (hex, boundspan) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intspanset_width(p, boundspan != null && boundspan); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 bigintspansetWidth = + (hex, boundspan) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.bigintspanset_width(p, boundspan != null && boundspan); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 floatspansetWidth = + (hex, boundspan) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.floatspanset_width(p, boundspan != null && boundspan); } + finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Date span/spanset accessors (date represented as int days) + // ------------------------------------------------------------------ + + public static final UDF1 startDate = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.datespanset_start_date(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 endDate = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.datespanset_end_date(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 numDates = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.datespanset_num_dates(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 dateN = + (hex, n) -> { + if (hex == null || n == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.datespanset_date_n(p, n); + if (r == null) return null; + // Pointer has the date as 4 bytes — read as int + int date = r.getInt(0); + return date; + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 dates = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.datespanset_dates(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // tnumber valueSpans (already exists as tnumberValuespans, add alias) + // ------------------------------------------------------------------ + + public static final UDF1 valueSpan = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.tnumber_to_span(p); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Typed set values — return Java arrays of primitive boxes + // ------------------------------------------------------------------ + + public static final UDF1 intsetValues = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Integer[] out = new Integer[n]; + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer outBuf = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) { + if (org.mobilitydb.spark.MeosNative.INSTANCE.intset_value_n(p, i + 1, outBuf)) { + out[i] = outBuf.getInt(0); + } + } + return out; + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 bigintsetValues = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Long[] out = new Long[n]; + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer outBuf = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) { + if (org.mobilitydb.spark.MeosNative.INSTANCE.bigintset_value_n(p, i + 1, outBuf)) { + out[i] = outBuf.getLong(0); + } + } + return out; + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Array-returning bbox accessors (Spark ArrayType) + // + // Note on TBox/STBox struct sizes: the returned pointer is a flat array + // of contiguous structs, so we need sizeof to advance per element. + // Both struct sizes are stable across MEOS releases since adding a new + // field would break ABI; if MEOS changes them, regenerate JMEOS and + // adjust here. + // ------------------------------------------------------------------ + + private static final int TBOX_SIZE = 56; // Span period(24) + Span span(24) + int16 flags(2) + 6 bytes padding + private static final int STBOX_SIZE = 80; // Span period(24) + 6×double(48) + int32 srid(4) + int16 flags(2) + 2 bytes padding + + public static final UDF1 tboxes = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.tnumber_tboxes(p, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) { + Pointer elem = arr.slice(i * TBOX_SIZE); + out[i] = functions.tbox_as_hexwkb(elem, (byte) 0, sizeOut); + } + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + private static final int SPAN_SIZE = 24; // 4 byte header + 4 padding + 2 Datum (8 each) + + public static final UDF3 intspanBins = + (hex, vsize, vorigin) -> { + if (hex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.intspan_bins(p, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF3 bigintspanBins = + (hex, vsize, vorigin) -> { + if (hex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.bigintspan_bins(p, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Split-by-N functions (return arrays of Span/TBox/STBox hex-WKB) + // ------------------------------------------------------------------ + + private interface SplitFn { Pointer apply(Pointer t, int n, Pointer count); } + + private static String[] splitArrSpan(String hex, Integer n, SplitFn fn) { + if (hex == null || n == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = fn.apply(t, n, countOut); + if (arr == null) return null; + try { + int cnt = countOut.getInt(0); + String[] out = new String[cnt]; + for (int i = 0; i < cnt; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + } + + private static String[] splitArrTbox(String hex, Integer n, SplitFn fn) { + if (hex == null || n == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = fn.apply(t, n, countOut); + if (arr == null) return null; + try { + int cnt = countOut.getInt(0); + String[] out = new String[cnt]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < cnt; i++) out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + } + + private static String[] splitArrStbox(String hex, Integer n, SplitFn fn) { + if (hex == null || n == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = fn.apply(t, n, countOut); + if (arr == null) return null; + try { + int cnt = countOut.getInt(0); + String[] out = new String[cnt]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < cnt; i++) out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + } + + public static final UDF2 splitNSpans = + (h, n) -> splitArrSpan(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::temporal_split_n_spans); + + public static final UDF2 splitEachNSpans = + (h, n) -> splitArrSpan(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::temporal_split_each_n_spans); + + public static final UDF2 splitNTboxes = + (h, n) -> splitArrTbox(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::tnumber_split_n_tboxes); + + public static final UDF2 splitEachNTboxes = + (h, n) -> splitArrTbox(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::tnumber_split_each_n_tboxes); + + public static final UDF2 splitNStboxes = + (h, n) -> splitArrStbox(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::tgeo_split_n_stboxes); + + public static final UDF2 splitEachNStboxes = + (h, n) -> splitArrStbox(h, n, org.mobilitydb.spark.MeosNative.INSTANCE::tgeo_split_each_n_stboxes); + + // ------------------------------------------------------------------ + // Temporal time bins / tstzspan bins (interval input as ISO 8601 string) + // ------------------------------------------------------------------ + + private static long tsToPgEpochMicros(java.sql.Timestamp ts) { + return (ts.getTime() - 946684800L * 1000L) * 1000L; + } + + public static final org.apache.spark.sql.api.java.UDF3 + timeBins = (hex, intervalStr, origin) -> { + if (hex == null || intervalStr == null || origin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_time_bins(t, iv, tsToPgEpochMicros(origin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t, iv); } + }; + + // ------------------------------------------------------------------ + // stbox_quad_split + getBin scalar + // ------------------------------------------------------------------ + + public static final UDF1 quadSplit = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer s = functions.stbox_from_hexwkb(hex); + if (s == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.stbox_quad_split(s, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(s); } + }; + + // getBin(timestamptz, interval, origin) → timestamptz (start of bin) + public static final org.apache.spark.sql.api.java.UDF3 + timestamptzGetBin = (ts, intervalStr, origin) -> { + if (ts == null || intervalStr == null || origin == null) return null; + MeosThread.ensureReady(); + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + try { + long binStart = org.mobilitydb.spark.MeosNative.INSTANCE + .timestamptz_get_bin(tsToPgEpochMicros(ts), iv, tsToPgEpochMicros(origin)); + // Convert PG-epoch micros → java Timestamp + long unixMicros = binStart + 946684800L * 1000000L; + return new java.sql.Timestamp(unixMicros / 1000); + } finally { MeosMemory.free(iv); } + }; + + public static final UDF3 tintValueBins = + (hex, vsize, vorigin) -> { + if (hex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.tint_value_bins(t, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + }; + + public static final UDF3 tfloatValueBins = + (hex, vsize, vorigin) -> { + if (hex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.tfloat_value_bins(t, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + }; + + public static final org.apache.spark.sql.api.java.UDF3 + tstzspanBins = (hex, intervalStr, origin) -> { + if (hex == null || intervalStr == null || origin == null) return null; + MeosThread.ensureReady(); + Pointer s = functions.span_from_hexwkb(hex); + if (s == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(s); return null; } + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE + .tstzspan_bins(s, iv, tsToPgEpochMicros(origin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(s, iv); } + }; + + public static final UDF3 floatspanBins = + (hex, vsize, vorigin) -> { + if (hex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.floatspan_bins(p, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) out[i] = functions.span_as_hexwkb(arr.slice(i * SPAN_SIZE), (byte) 0); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 stboxes = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE.tgeo_stboxes(p, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) { + Pointer elem = arr.slice(i * STBOX_SIZE); + out[i] = functions.stbox_as_hexwkb(elem, (byte) 0, sizeOut); + } + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Time-weighted average value of tnumber + // ------------------------------------------------------------------ + + public static final UDF1 avgValue = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return org.mobilitydb.spark.MeosNative.INSTANCE.tnumber_avg_value(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 floatsetValues = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Double[] out = new Double[n]; + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer outBuf = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) { + if (org.mobilitydb.spark.MeosNative.INSTANCE.floatset_value_n(p, i + 1, outBuf)) { + out[i] = outBuf.getDouble(0); + } + } + return out; + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Per-type setFromBinary aliases — generic byte[]→hex→set_from_hexwkb + // ------------------------------------------------------------------ + + private static UDF1 setFromBinaryFn() { + return bytes -> { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.set_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + // ------------------------------------------------------------------ + // Array-returning accessors (return Spark ArrayType) + // ------------------------------------------------------------------ + + // spans(spanset) → array of span hex-WKB strings + public static final UDF1 spans = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.spanset_num_spans(p); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + // 1-based per MEOS convention + Pointer span = functions.spanset_span_n(p, i + 1); + if (span == null) { out[i] = null; continue; } + out[i] = functions.span_as_hexwkb(span, (byte) 0); + // span_n returns a fresh copy in newer MEOS; free it + MeosMemory.free(span); + } + return out; + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 intsetFromBinary = setFromBinaryFn(); + public static final UDF1 bigintsetFromBinary = setFromBinaryFn(); + public static final UDF1 floatsetFromBinary = setFromBinaryFn(); + public static final UDF1 textsetFromBinary = setFromBinaryFn(); + public static final UDF1 tstzsetFromBinary = setFromBinaryFn(); + public static final UDF1 datesetFromBinary = setFromBinaryFn(); + + public static void registerAll(SparkSession spark) { + spark.udf().register("intspanWidth", intspanWidth, DataTypes.IntegerType); + spark.udf().register("bigintspanWidth", bigintspanWidth, DataTypes.LongType); + spark.udf().register("floatspanWidth", floatspanWidth, DataTypes.DoubleType); + spark.udf().register("intspansetWidth", intspansetWidth, DataTypes.IntegerType); + spark.udf().register("bigintspansetWidth", bigintspansetWidth, DataTypes.LongType); + spark.udf().register("floatspansetWidth", floatspansetWidth, DataTypes.DoubleType); + // single-arg width aliases (boundspan defaults to false in tests) + spark.udf().register("width", floatspanWidth, DataTypes.DoubleType); + + spark.udf().register("startDate", startDate, DataTypes.IntegerType); + spark.udf().register("endDate", endDate, DataTypes.IntegerType); + spark.udf().register("numDates", numDates, DataTypes.IntegerType); + spark.udf().register("dateN", dateN, DataTypes.IntegerType); + spark.udf().register("dates", dates, DataTypes.StringType); + + spark.udf().register("valueSpan", valueSpan, DataTypes.StringType); + + spark.udf().register("intsetFromBinary", intsetFromBinary, DataTypes.StringType); + spark.udf().register("bigintsetFromBinary", bigintsetFromBinary, DataTypes.StringType); + spark.udf().register("floatsetFromBinary", floatsetFromBinary, DataTypes.StringType); + spark.udf().register("textsetFromBinary", textsetFromBinary, DataTypes.StringType); + spark.udf().register("tstzsetFromBinary", tstzsetFromBinary, DataTypes.StringType); + spark.udf().register("datesetFromBinary", datesetFromBinary, DataTypes.StringType); + + // Array-returning accessors + spark.udf().register("spans", spans, DataTypes.createArrayType(DataTypes.StringType)); + + // tgeo type conversions + spark.udf().register("tgeometry", tgeometry, DataTypes.StringType); + spark.udf().register("tgeography", tgeography, DataTypes.StringType); + // MobilityDB SQL bare-name aliases + spark.udf().register("geometry", tgeometry, DataTypes.StringType); + spark.udf().register("geography", tgeography, DataTypes.StringType); + // Introspection + spark.udf().register("mobilitydbVersion", mobilitydbVersion, DataTypes.StringType); + spark.udf().register("mobilitydbFullVersion", mobilitydbFullVersion, DataTypes.StringType); + // valueSet (Datum-array → typed Set), segmentMin/MaxDuration, box3d + spark.udf().register("valueSet", valueSet, DataTypes.StringType); + spark.udf().register("segmentMinDuration", segmentMinDuration, DataTypes.StringType); + spark.udf().register("segmentMaxDuration", segmentMaxDuration, DataTypes.StringType); + spark.udf().register("box2d", box2d, DataTypes.StringType); + spark.udf().register("box3d", box3d, DataTypes.StringType); + // Typed set values (array-returning) + spark.udf().register("intsetValues", intsetValues, DataTypes.createArrayType(DataTypes.IntegerType)); + spark.udf().register("bigintsetValues", bigintsetValues, DataTypes.createArrayType(DataTypes.LongType)); + spark.udf().register("floatsetValues", floatsetValues, DataTypes.createArrayType(DataTypes.DoubleType)); + // MobilityDB SQL bare-name aliases (typed dispatchers — picks float as default) + spark.udf().register("getValues", floatsetValues, DataTypes.createArrayType(DataTypes.DoubleType)); + spark.udf().register("unnest", floatsetValues, DataTypes.createArrayType(DataTypes.DoubleType)); + // Time tiling + spark.udf().register("timeBins", timeBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tstzspanBins", tstzspanBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintValueBins", tintValueBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tfloatValueBins", tfloatValueBins, DataTypes.createArrayType(DataTypes.StringType)); + // Bare-name alias (defaults to float) + spark.udf().register("valueBins", tfloatValueBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("quadSplit", quadSplit, DataTypes.createArrayType(DataTypes.StringType)); + // Scalar getBin for timestamptz; numeric variants are floatBucket/intBucket + spark.udf().register("timestamptzGetBin", timestamptzGetBin, DataTypes.TimestampType); + spark.udf().register("getBin", timestamptzGetBin, DataTypes.TimestampType); + spark.udf().register("avgValue", avgValue, DataTypes.DoubleType); + spark.udf().register("tboxes", tboxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("stboxes", stboxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("intspanBins", intspanBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("bigintspanBins", bigintspanBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("floatspanBins", floatspanBins, DataTypes.createArrayType(DataTypes.StringType)); + // MobilityDB SQL bare-name alias + spark.udf().register("bins", floatspanBins, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitNSpans", splitNSpans, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitEachNSpans", splitEachNSpans, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitNTboxes", splitNTboxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitEachNTboxes", splitEachNTboxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitNStboxes", splitNStboxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("splitEachNStboxes", splitEachNStboxes, DataTypes.createArrayType(DataTypes.StringType)); + } + + // ------------------------------------------------------------------ + // Introspection + // ------------------------------------------------------------------ + + public static final org.apache.spark.sql.api.java.UDF0 mobilitydbVersion = + () -> { + MeosThread.ensureReady(); + return org.mobilitydb.spark.MeosNative.INSTANCE.mobilitydb_version(); + }; + + public static final org.apache.spark.sql.api.java.UDF0 mobilitydbFullVersion = + () -> { + MeosThread.ensureReady(); + return org.mobilitydb.spark.MeosNative.INSTANCE.mobilitydb_full_version(); + }; + + // ------------------------------------------------------------------ + // tgeo type conversions + // ------------------------------------------------------------------ + + // ------------------------------------------------------------------ + // valueSet, segmentMin/MaxDuration, box3d (PostGIS embedded in MEOS) + // ------------------------------------------------------------------ + + // valueSet(temporal) → set hex containing distinct values. + // Mirrors MobilityDB's PG-side Temporal_valueset: + // 1. temporal_values_p → Datum* + count + // 2. temptype_basetype(temptype) → MeosType basetype + // 3. set_make_free → Set* (consumes the Datum* array) + public static final UDF1 valueSet = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + try { + int temptype = t.getByte(4) & 0xff; + int basetype = org.mobilitydb.spark.MeosNative.INSTANCE.temptype_basetype(temptype); + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer values = org.mobilitydb.spark.MeosNative.INSTANCE.temporal_values_p(t, countOut); + if (values == null) return null; + int count = countOut.getInt(0); + Pointer s = org.mobilitydb.spark.MeosNative.INSTANCE + .set_make_free(values, count, basetype, false); + if (s == null) return null; + try { return functions.set_as_hexwkb(s, (byte) 0); } + finally { MeosMemory.free(s); } + } finally { MeosMemory.free(t); } + }; + + // segmentMinDuration(temporal, intervalStr, strict) → temporal sequence-set + public static final org.apache.spark.sql.api.java.UDF3 + segmentMinDuration = (hex, intervalStr, strict) -> segmDuration(hex, intervalStr, strict, true); + + public static final org.apache.spark.sql.api.java.UDF3 + segmentMaxDuration = (hex, intervalStr, strict) -> segmDuration(hex, intervalStr, strict, false); + + private static String segmDuration(String hex, String intervalStr, Boolean strict, boolean atleast) { + if (hex == null || intervalStr == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(hex); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_segm_duration(t, iv, atleast, strict != null && strict); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(t, iv); } + } + + // box2d(stbox) → text representation "BOX(xmin ymin,xmax ymax)" + // PostGIS BOX2D / GBOX type (embedded in MEOS). + public static final UDF1 box2d = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer s = functions.stbox_from_hexwkb(hex); + if (s == null) return null; + try { + Pointer b = org.mobilitydb.spark.MeosNative.INSTANCE.stbox_to_gbox(s); + if (b == null) return null; + try { return org.mobilitydb.spark.MeosNative.INSTANCE.gbox_out(b, 15); } + finally { MeosMemory.free(b); } + } finally { MeosMemory.free(s); } + }; + + // box3d(stbox) → text representation "BOX3D(xmin ymin zmin,xmax ymax zmax)" + // PostGIS BOX3D type (embedded in MEOS). + public static final UDF1 box3d = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer s = functions.stbox_from_hexwkb(hex); + if (s == null) return null; + try { + Pointer b = org.mobilitydb.spark.MeosNative.INSTANCE.stbox_to_box3d(s); + if (b == null) return null; + try { return org.mobilitydb.spark.MeosNative.INSTANCE.box3d_out(b, 15); } + finally { MeosMemory.free(b); } + } finally { MeosMemory.free(s); } + }; + + public static final UDF1 tgeometry = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + // Try tgeompoint → tgeometry first; if that fails, try tgeography → tgeometry + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.tgeompoint_to_tgeometry(p); + if (r == null) r = org.mobilitydb.spark.MeosNative.INSTANCE.tgeography_to_tgeometry(p); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 tgeography = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.tgeogpoint_to_tgeography(p); + if (r == null) r = org.mobilitydb.spark.MeosNative.INSTANCE.tgeometry_to_tgeography(p); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/AccessorUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/AccessorUDFs.java new file mode 100644 index 00000000..954cdcd7 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/AccessorUDFs.java @@ -0,0 +1,654 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.sql.Timestamp; + +/** + * Spark SQL UDFs for temporal accessor and manipulation operations. + * + * Naming convention mirrors MobilityDuck where possible, using camelCase for + * Spark SQL UDF names. Type-specific UDFs use a type prefix (tfloat*, tint*) + * where the return type depends on the base temporal type. + * + * MEOS function authority: meos/include/meos.h + */ +public final class AccessorUDFs { + + private AccessorUDFs() {} + + // ------------------------------------------------------------------ + // Type-agnostic accessors (return type does not depend on base type) + // ------------------------------------------------------------------ + + // numSequences(trip STRING) → INT + // MEOS: temporal_num_sequences(const Temporal *) → int + public static final UDF1 numSequences = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.temporal_num_sequences(ptr); + }; + + // interp(trip STRING) → STRING ("Discrete" | "Stepwise" | "Linear") + // MEOS: temporal_interp(const Temporal *) → char * + public static final UDF1 interp = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.temporal_interp(ptr); + }; + + // time(trip STRING) → STRING (hex-WKB of tstzspanset bounding the instants) + // MEOS: temporal_time(const Temporal *) → SpanSet * + public static final UDF1 time = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer ss = functions.temporal_time(ptr); + if (ss == null) return null; + return functions.spanset_as_hexwkb(ss, (byte) 0); + }; + + // timespan(trip STRING) → STRING (hex-WKB of tstzspan — overall bounding period) + // MEOS: temporal_to_tstzspan(const Temporal *) → Span * + public static final UDF1 timespan = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer s = functions.temporal_to_tstzspan(ptr); + if (s == null) return null; + return functions.span_as_hexwkb(s, (byte) 0); + }; + + // merge(trip1 STRING, trip2 STRING) → STRING + // MEOS: temporal_merge(const Temporal *, const Temporal *) → Temporal * + public static final UDF2 merge = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer result = functions.temporal_merge(p1, p2); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // shift(trip STRING, deltaStr STRING) → STRING + // deltaStr is a PostgreSQL interval literal, e.g. "1 day" or "01:00:00". + // MEOS: temporal_shift_time(const Temporal *, const Interval *) → Temporal * + public static final UDF2 shift = + (trip, deltaStr) -> { + if (trip == null || deltaStr == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer ivPtr = functions.pg_interval_in(deltaStr, -1); + if (tptr == null || ivPtr == null) return null; + Pointer result = functions.temporal_shift_time(tptr, ivPtr); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // scale(trip STRING, durationStr STRING) → STRING + // MEOS: temporal_scale_time(const Temporal *, const Interval *) → Temporal * + public static final UDF2 scale = + (trip, durationStr) -> { + if (trip == null || durationStr == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer ivPtr = functions.pg_interval_in(durationStr, -1); + if (tptr == null || ivPtr == null) return null; + Pointer result = functions.temporal_scale_time(tptr, ivPtr); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // atSpan(trip STRING, spanHex STRING) → STRING + // MEOS: temporal_at_tstzspan(const Temporal *, const Span *) → Temporal * + public static final UDF2 atSpan = + (trip, spanHex) -> { + if (trip == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer sptr = functions.span_from_hexwkb(spanHex); + if (tptr == null || sptr == null) return null; + Pointer result = functions.temporal_at_tstzspan(tptr, sptr); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // atSpanset(trip STRING, spansetHex STRING) → STRING + // MEOS: temporal_at_tstzspanset(const Temporal *, const SpanSet *) → Temporal * + public static final UDF2 atSpanset = + (trip, spansetHex) -> { + if (trip == null || spansetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer ssptr = functions.spanset_from_hexwkb(spansetHex); + if (tptr == null || ssptr == null) return null; + Pointer result = functions.temporal_at_tstzspanset(tptr, ssptr); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // insert(trip1 STRING, trip2 STRING) → STRING + // MEOS: temporal_insert(const Temporal *, const Temporal *, bool connect) → Temporal * + public static final UDF2 insert = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer result = functions.temporal_insert(p1, p2, true); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // update(trip1 STRING, trip2 STRING) → STRING + // MEOS: temporal_update(const Temporal *, const Temporal *, bool connect) → Temporal * + public static final UDF2 update = + (trip1, trip2) -> { + if (trip1 == null || trip2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(trip1); + Pointer p2 = functions.temporal_from_hexwkb(trip2); + if (p1 == null || p2 == null) return null; + Pointer result = functions.temporal_update(p1, p2, true); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Type-specific value accessors (return type matches the base type) + // ------------------------------------------------------------------ + + // tfloatStartValue(trip STRING) → DOUBLE + // MEOS: tfloat_start_value(const Temporal *) → double + public static final UDF1 tfloatStartValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tfloat_start_value(ptr); + }; + + // tfloatEndValue(trip STRING) → DOUBLE + // MEOS: tfloat_end_value(const Temporal *) → double + public static final UDF1 tfloatEndValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tfloat_end_value(ptr); + }; + + // tfloatMinValue(trip STRING) → DOUBLE + // MEOS: tfloat_min_value(const Temporal *) → double + public static final UDF1 tfloatMinValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tfloat_min_value(ptr); + }; + + // tfloatMaxValue(trip STRING) → DOUBLE + // MEOS: tfloat_max_value(const Temporal *) → double + public static final UDF1 tfloatMaxValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tfloat_max_value(ptr); + }; + + // tintStartValue(trip STRING) → INT + // MEOS: tint_start_value(const Temporal *) → int + public static final UDF1 tintStartValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tint_start_value(ptr); + }; + + // tintEndValue(trip STRING) → INT + // MEOS: tint_end_value(const Temporal *) → int + public static final UDF1 tintEndValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tint_end_value(ptr); + }; + + // tintMinValue(trip STRING) → INT + // MEOS: tint_min_value(const Temporal *) → int + public static final UDF1 tintMinValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tint_min_value(ptr); + }; + + // tintMaxValue(trip STRING) → INT + // MEOS: tint_max_value(const Temporal *) → int + public static final UDF1 tintMaxValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tint_max_value(ptr); + }; + + // tboolStartValue(trip STRING) → BOOLEAN + // MEOS: tbool_start_value(const Temporal *) → bool + public static final UDF1 tboolStartValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tbool_start_value(ptr); + }; + + // tboolEndValue(trip STRING) → BOOLEAN + // MEOS: tbool_end_value(const Temporal *) → bool + public static final UDF1 tboolEndValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + return functions.tbool_end_value(ptr); + }; + + // tpointStartValue(trip STRING) → STRING (WKT of start geometry) + // MEOS: tpoint_start_value(const Temporal *) → GSERIALIZED * + public static final UDF1 tpointStartValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer gs = functions.tgeo_start_value(ptr); + if (gs == null) return null; + return functions.geo_as_text(gs, 6); + }; + + // tpointEndValue(trip STRING) → STRING (WKT of end geometry) + // MEOS: tpoint_end_value(const Temporal *) → GSERIALIZED * + public static final UDF1 tpointEndValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer gs = functions.tgeo_end_value(ptr); + if (gs == null) return null; + return functions.geo_as_text(gs, 6); + }; + + // ttextStartValue(trip STRING) → STRING (text value at start) + // MEOS: ttext_start_value(const Temporal *) → text * + public static final UDF1 ttextStartValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer txt = functions.ttext_start_value(ptr); + if (txt == null) return null; + return functions.text_out(txt); + }; + + // ttextEndValue(trip STRING) → STRING (text value at end) + // MEOS: ttext_end_value(const Temporal *) → text * + public static final UDF1 ttextEndValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer txt = functions.ttext_end_value(ptr); + if (txt == null) return null; + return functions.text_out(txt); + }; + + // ------------------------------------------------------------------ + // Value restriction: atMin / atMax / atValues / minusTime / minusMin / minusMax + // ------------------------------------------------------------------ + + // atMin(trip STRING) → STRING + public static final UDF1 atMin = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer r = functions.temporal_at_min(ptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // atMax(trip STRING) → STRING + public static final UDF1 atMax = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer r = functions.temporal_at_max(ptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // atValues(trip STRING, setHex STRING) → STRING + public static final UDF2 atValues = + (trip, setHex) -> { + if (trip == null || setHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer sptr = functions.set_from_hexwkb(setHex); + if (tptr == null || sptr == null) return null; + Pointer r = functions.temporal_at_values(tptr, sptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // minusTime(trip STRING, tstzspanHex STRING) → STRING + public static final UDF2 minusTime = + (trip, spanHex) -> { + if (trip == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer sptr = functions.span_from_hexwkb(spanHex); + if (tptr == null || sptr == null) return null; + Pointer r = functions.temporal_minus_tstzspan(tptr, sptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // minusMin(trip STRING) → STRING + public static final UDF1 minusMin = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer r = functions.temporal_minus_min(ptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // minusMax(trip STRING) → STRING + public static final UDF1 minusMax = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer r = functions.temporal_minus_max(ptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Spatio-temporal restriction: atStbox / minusStbox / tnumberAtTbox / tnumberMinusTbox + // ------------------------------------------------------------------ + + // atStbox(trip STRING, stboxHex STRING) → STRING + public static final UDF2 atStbox = + (trip, stboxHex) -> { + if (trip == null || stboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer bptr = functions.stbox_from_hexwkb(stboxHex); + if (tptr == null || bptr == null) return null; + Pointer r = functions.tgeo_at_stbox(tptr, bptr, true); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // minusStbox(trip STRING, stboxHex STRING) → STRING + public static final UDF2 minusStbox = + (trip, stboxHex) -> { + if (trip == null || stboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer bptr = functions.stbox_from_hexwkb(stboxHex); + if (tptr == null || bptr == null) return null; + Pointer r = functions.tgeo_minus_stbox(tptr, bptr, true); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // tnumberAtTbox(trip STRING, tboxHex STRING) → STRING + public static final UDF2 tnumberAtTbox = + (trip, tboxHex) -> { + if (trip == null || tboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer bptr = functions.tbox_from_hexwkb(tboxHex); + if (tptr == null || bptr == null) return null; + Pointer r = functions.tnumber_at_tbox(tptr, bptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // tnumberMinusTbox(trip STRING, tboxHex STRING) → STRING + public static final UDF2 tnumberMinusTbox = + (trip, tboxHex) -> { + if (trip == null || tboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer bptr = functions.tbox_from_hexwkb(tboxHex); + if (tptr == null || bptr == null) return null; + Pointer r = functions.tnumber_minus_tbox(tptr, bptr); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Append operations + // ------------------------------------------------------------------ + + // appendInstant(trip STRING, instantHex STRING) → STRING + public static final UDF2 appendInstant = + (trip, instantHex) -> { + if (trip == null || instantHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer iptr = functions.temporal_from_hexwkb(instantHex); + if (tptr == null || iptr == null) return null; + Pointer r = functions.temporal_append_tinstant(tptr, iptr, 0.0, null, false); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // appendSequence(trip STRING, seqHex STRING) → STRING + public static final UDF2 appendSequence = + (trip, seqHex) -> { + if (trip == null || seqHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + Pointer sptr = functions.temporal_from_hexwkb(seqHex); + if (tptr == null || sptr == null) return null; + Pointer r = functions.temporal_append_tsequence(tptr, sptr, false); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Value span: tnumberValuespans, tnumberToSpan, tnumberToTbox + // ------------------------------------------------------------------ + + // tnumberValuespans(trip STRING) → STRING (hex-WKB of value spanset) + public static final UDF1 tnumberValuespans = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + Pointer ss = functions.tnumber_valuespans(ptr); + if (ss == null) return null; + return functions.spanset_as_hexwkb(ss, (byte) 0); + }; + + // tnumberToSpan(trip STRING) → STRING (hex-WKB of value span covering all values) + // MEOS: tnumber_to_span(const Temporal *) → Span * + public static final UDF1 tnumberToSpan = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer sp = functions.tnumber_to_span(ptr); + if (sp == null) return null; + try { + return functions.span_as_hexwkb(sp, (byte) 0); + } finally { + MeosMemory.free(sp); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tnumberToTbox(trip STRING) → STRING (hex-WKB of TBox bounding box) + // MEOS: tnumber_to_tbox(const Temporal *) → TBox * + public static final UDF1 tnumberToTbox = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer tb = functions.tnumber_to_tbox(ptr); + if (tb == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + jnr.ffi.Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(tb, (byte) 0, sizeOut); + } finally { + MeosMemory.free(tb); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static void registerAll(SparkSession spark) { + // Type-agnostic + spark.udf().register("numSequences", numSequences, DataTypes.IntegerType); + spark.udf().register("interp", interp, DataTypes.StringType); + spark.udf().register("time", time, DataTypes.StringType); + spark.udf().register("timespan", timespan, DataTypes.StringType); + spark.udf().register("merge", merge, DataTypes.StringType); + spark.udf().register("shift", shift, DataTypes.StringType); + spark.udf().register("scale", scale, DataTypes.StringType); + spark.udf().register("atSpan", atSpan, DataTypes.StringType); + spark.udf().register("atSpanset", atSpanset, DataTypes.StringType); + spark.udf().register("insert", insert, DataTypes.StringType); + spark.udf().register("update", update, DataTypes.StringType); + // Type-specific float + spark.udf().register("tfloatStartValue", tfloatStartValue, DataTypes.DoubleType); + spark.udf().register("tfloatEndValue", tfloatEndValue, DataTypes.DoubleType); + spark.udf().register("tfloatMinValue", tfloatMinValue, DataTypes.DoubleType); + spark.udf().register("tfloatMaxValue", tfloatMaxValue, DataTypes.DoubleType); + // Type-specific int + spark.udf().register("tintStartValue", tintStartValue, DataTypes.IntegerType); + spark.udf().register("tintEndValue", tintEndValue, DataTypes.IntegerType); + spark.udf().register("tintMinValue", tintMinValue, DataTypes.IntegerType); + spark.udf().register("tintMaxValue", tintMaxValue, DataTypes.IntegerType); + // Type-specific bool + spark.udf().register("tboolStartValue", tboolStartValue, DataTypes.BooleanType); + spark.udf().register("tboolEndValue", tboolEndValue, DataTypes.BooleanType); + // Type-specific point (returns WKT) + spark.udf().register("tpointStartValue", tpointStartValue, DataTypes.StringType); + spark.udf().register("tpointEndValue", tpointEndValue, DataTypes.StringType); + // Type-specific text + spark.udf().register("ttextStartValue", ttextStartValue, DataTypes.StringType); + spark.udf().register("ttextEndValue", ttextEndValue, DataTypes.StringType); + // MobilityDB SQL bare-name `getValue` aliases — for an instant temporal, + // value-at-instant === start-value. Per-type variants for type safety. + spark.udf().register("tintGetValue", tintStartValue, DataTypes.IntegerType); + spark.udf().register("tfloatGetValue", tfloatStartValue, DataTypes.DoubleType); + spark.udf().register("tboolGetValue", tboolStartValue, DataTypes.BooleanType); + spark.udf().register("ttextGetValue", ttextStartValue, DataTypes.StringType); + spark.udf().register("tpointGetValue", tpointStartValue, DataTypes.StringType); + // Bare-name alias defaults to tfloat (most common analytics case) + spark.udf().register("getValue", tfloatStartValue, DataTypes.DoubleType); + // Value restriction + spark.udf().register("atMin", atMin, DataTypes.StringType); + spark.udf().register("atMax", atMax, DataTypes.StringType); + spark.udf().register("atValues", atValues, DataTypes.StringType); + spark.udf().register("minusTime", minusTime, DataTypes.StringType); + spark.udf().register("minusMin", minusMin, DataTypes.StringType); + spark.udf().register("minusMax", minusMax, DataTypes.StringType); + // Spatio-temporal restriction + spark.udf().register("atStbox", atStbox, DataTypes.StringType); + spark.udf().register("minusStbox", minusStbox, DataTypes.StringType); + spark.udf().register("tnumberAtTbox", tnumberAtTbox, DataTypes.StringType); + spark.udf().register("tnumberMinusTbox", tnumberMinusTbox, DataTypes.StringType); + // Append + spark.udf().register("appendInstant", appendInstant, DataTypes.StringType); + spark.udf().register("appendSequence", appendSequence, DataTypes.StringType); + // Value spans + spark.udf().register("tnumberValuespans", tnumberValuespans, DataTypes.StringType); + spark.udf().register("tnumberToSpan", tnumberToSpan, DataTypes.StringType); + spark.udf().register("tnumberToTbox", tnumberToTbox, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/AggregateUDAFs.java b/src/main/java/org/mobilitydb/spark/temporal/AggregateUDAFs.java new file mode 100644 index 00000000..67a15e6b --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/AggregateUDAFs.java @@ -0,0 +1,510 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.Encoder; +import org.apache.spark.sql.Encoders; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.expressions.Aggregator; + +import java.io.Serializable; + +/** + * Spark SQL UDAFs (typed Aggregators) for temporal aggregate functions. + * + * Each UDAF collects hex-WKB strings from each row into a newline-delimited + * buffer (BUF = String). The actual MEOS aggregation runs inside finish() + * by replaying the transfn over each collected value and calling finalfn. + * This design keeps the buffer serializable between Spark stages while still + * using the correct MEOS aggregate semantics. + * + * MEOS function authority: meos/include/meos.h (temporal aggregate transfns) + * + * Registration: call registerAll(spark). In SQL, use tCount(col), + * tAnd(col), tOr(col), tIntMin(col), tIntMax(col), tIntSum(col), + * tFloatMin(col), tFloatMax(col), tFloatSum(col), tTextMin(col), + * tTextMax(col), tCentroid(col), tExtent(col). + */ +public final class AggregateUDAFs { + + private AggregateUDAFs() {} + + // ------------------------------------------------------------------ + // Shared helpers + // ------------------------------------------------------------------ + + /** Split buffer on newlines; skip blank entries. */ + private static String[] entries(String buf) { + if (buf == null || buf.isBlank()) return new String[0]; + return buf.split("\n"); + } + + private static String append(String buf, String hex) { + if (hex == null || hex.isBlank()) return buf; + if (buf == null || buf.isBlank()) return hex; + return buf + "\n" + hex; + } + + private static String merge(String b1, String b2) { + if (b1 == null || b1.isBlank()) return b2; + if (b2 == null || b2.isBlank()) return b1; + return b1 + "\n" + b2; + } + + /** Serialize a temporal Pointer to hex-WKB and free it. */ + private static String hexOut(Pointer r) { + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } + + /** Serialize an STBox Pointer to hex-WKB and free it. */ + private static String stboxHex(Pointer p) { + if (p == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { + MeosMemory.free(p); + } + } + + // ------------------------------------------------------------------ + // tCount — count how many temporal values are defined at each instant + // Returns: tint hex-WKB + // MEOS: temporal_tcount_transfn + temporal_tagg_finalfn + // ------------------------------------------------------------------ + + public static final class TCountFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + + @Override public String reduce(String buf, String hex) { + return append(buf, hex); + } + + @Override public String merge(String b1, String b2) { + return AggregateUDAFs.merge(b1, b2); + } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.temporal_tcount_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tAnd — temporal AND over tbool values + // Returns: tbool hex-WKB + // MEOS: tbool_tand_transfn + temporal_tagg_finalfn + // ------------------------------------------------------------------ + + public static final class TAndFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tbool_tand_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tOr — temporal OR over tbool values + // Returns: tbool hex-WKB + // MEOS: tbool_tor_transfn + temporal_tagg_finalfn + // ------------------------------------------------------------------ + + public static final class TOrFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tbool_tor_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tIntMin / tIntMax / tIntSum — temporal aggregates on tint + // Returns: tint hex-WKB + // ------------------------------------------------------------------ + + public static final class TIntMinFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tint_tmin_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + public static final class TIntMaxFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tint_tmax_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + public static final class TIntSumFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tint_tsum_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tFloatMin / tFloatMax / tFloatSum — temporal aggregates on tfloat + // Returns: tfloat hex-WKB + // ------------------------------------------------------------------ + + public static final class TFloatMinFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tfloat_tmin_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + public static final class TFloatMaxFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tfloat_tmax_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + public static final class TFloatSumFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tfloat_tsum_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tTextMin / tTextMax — temporal aggregates on ttext + // Returns: ttext hex-WKB + // ------------------------------------------------------------------ + + public static final class TTextMinFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.ttext_tmin_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + public static final class TTextMaxFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.ttext_tmax_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.temporal_tagg_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tCentroid — temporal centroid over tpoint values + // Returns: tpoint hex-WKB (the moving centroid of the input points) + // MEOS: tpoint_tcentroid_transfn + tpoint_tcentroid_finalfn + // ------------------------------------------------------------------ + + public static final class TCentroidFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tpoint_tcentroid_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + if (state == null) return null; + return hexOut(functions.tpoint_tcentroid_finalfn(state)); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // tExtent — bounding STBox over all tpoint values + // Returns: stbox hex-WKB + // MEOS: tspatial_extent_transfn (state is STBox*, not SkipList*) + // ------------------------------------------------------------------ + + public static final class TExtentFn extends Aggregator + implements Serializable { + @Override public String zero() { return ""; } + @Override public String reduce(String buf, String hex) { return append(buf, hex); } + @Override public String merge(String b1, String b2) { return AggregateUDAFs.merge(b1, b2); } + + @Override public String finish(String buf) { + MeosThread.ensureReady(); + String[] hexes = entries(buf); + if (hexes.length == 0) return null; + Pointer state = null; + for (String hex : hexes) { + Pointer inp = functions.temporal_from_hexwkb(hex); + if (inp == null) continue; + Pointer next = functions.tspatial_extent_transfn(state, inp); + MeosMemory.free(inp); + state = next; + } + return stboxHex(state); + } + + @Override public Encoder bufferEncoder() { return Encoders.STRING(); } + @Override public Encoder outputEncoder() { return Encoders.STRING(); } + } + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + spark.udf().register("tCount", org.apache.spark.sql.functions.udaf(new TCountFn(), Encoders.STRING())); + spark.udf().register("tAnd", org.apache.spark.sql.functions.udaf(new TAndFn(), Encoders.STRING())); + spark.udf().register("tOr", org.apache.spark.sql.functions.udaf(new TOrFn(), Encoders.STRING())); + spark.udf().register("tIntMin", org.apache.spark.sql.functions.udaf(new TIntMinFn(), Encoders.STRING())); + spark.udf().register("tIntMax", org.apache.spark.sql.functions.udaf(new TIntMaxFn(), Encoders.STRING())); + spark.udf().register("tIntSum", org.apache.spark.sql.functions.udaf(new TIntSumFn(), Encoders.STRING())); + spark.udf().register("tFloatMin", org.apache.spark.sql.functions.udaf(new TFloatMinFn(), Encoders.STRING())); + spark.udf().register("tFloatMax", org.apache.spark.sql.functions.udaf(new TFloatMaxFn(), Encoders.STRING())); + spark.udf().register("tFloatSum", org.apache.spark.sql.functions.udaf(new TFloatSumFn(), Encoders.STRING())); + spark.udf().register("tTextMin", org.apache.spark.sql.functions.udaf(new TTextMinFn(), Encoders.STRING())); + spark.udf().register("tTextMax", org.apache.spark.sql.functions.udaf(new TTextMaxFn(), Encoders.STRING())); + spark.udf().register("tCentroid", org.apache.spark.sql.functions.udaf(new TCentroidFn(), Encoders.STRING())); + spark.udf().register("tExtent", org.apache.spark.sql.functions.udaf(new TExtentFn(), Encoders.STRING())); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/AnalyticsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/AnalyticsUDFs.java new file mode 100644 index 00000000..ac6a7c81 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/AnalyticsUDFs.java @@ -0,0 +1,356 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for temporal analytics: numeric math and spatial aggregates. + * + * All temporal inputs use hex-WKB string encoding. Scalar outputs (length, + * integral, twavg) are returned as Java primitive types. + * + * Memory management: every Pointer returned by MEOS must be freed via + * MeosMemory.free() — see GeoUDFs for the rationale. + * + * MEOS function authority: meos/include/meos.h and meos/include/meos_geo.h + */ +public final class AnalyticsUDFs { + + private AnalyticsUDFs() {} + + // ------------------------------------------------------------------ + // tfloat math (hex-WKB in, hex-WKB out) + // ------------------------------------------------------------------ + + public static final UDF1 tfloatDerivative = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_derivative(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF2 tfloatRound = + (s, maxdd) -> { + if (s == null || maxdd == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_round(ptr, maxdd); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tfloatFloor = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tfloat_floor(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tfloatCeil = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tfloat_ceil(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF2 tfloatDegrees = + (s, normalize) -> { + if (s == null || normalize == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tfloat_degrees(ptr, normalize); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tfloatRadians = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tfloat_radians(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tnumber scalar aggregates (hex-WKB in, scalar out) + // ------------------------------------------------------------------ + + public static final UDF1 tnumberIntegral = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return functions.tnumber_integral(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tnumberTwavg = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return functions.tnumber_twavg(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + // tnumberTrend(tnumber_hex) → tfloat hex-WKB + // MEOS: tnumber_trend(const Temporal *) → Temporal * + public static final UDF1 tnumberTrend = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tnumber_trend(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tpoint spatial analytics (hex-WKB in, scalar/hex out) + // ------------------------------------------------------------------ + + public static final UDF1 tpointLength = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return functions.tpoint_length(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tpointSpeed = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tpoint_speed(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tpointAzimuth = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tpoint_azimuth(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tpointDirection = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tpoint_direction(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tpointCumulativeLength(tpoint_hex) → tfloat hex-WKB + // Returns the cumulative distance along the trajectory. + // MEOS: tpoint_cumulative_length(const Temporal *) → Temporal * + public static final UDF1 tpointCumulativeLength = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tpoint_cumulative_length(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tgeoTraversedArea(tgeo_hex) → WKT STRING + // Returns the geometry swept out by a temporal geometry. + // MEOS: tgeo_traversed_area(const Temporal *, bool unary_union) → GSERIALIZED * + public static final UDF1 tgeoTraversedArea = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer gsPtr = functions.tgeo_traversed_area(ptr, false); + if (gsPtr == null) return null; + try { + return functions.geo_as_text(gsPtr, 6); + } finally { + MeosMemory.free(gsPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("tfloatDerivative", tfloatDerivative, DataTypes.StringType); + spark.udf().register("tfloatRound", tfloatRound, DataTypes.StringType); + spark.udf().register("tfloatFloor", tfloatFloor, DataTypes.StringType); + spark.udf().register("tfloatCeil", tfloatCeil, DataTypes.StringType); + spark.udf().register("tfloatDegrees", tfloatDegrees, DataTypes.StringType); + spark.udf().register("tfloatRadians", tfloatRadians, DataTypes.StringType); + spark.udf().register("tnumberIntegral", tnumberIntegral, DataTypes.DoubleType); + spark.udf().register("tnumberTwavg", tnumberTwavg, DataTypes.DoubleType); + spark.udf().register("tnumberTrend", tnumberTrend, DataTypes.StringType); + spark.udf().register("tpointLength", tpointLength, DataTypes.DoubleType); + spark.udf().register("tpointSpeed", tpointSpeed, DataTypes.StringType); + spark.udf().register("tpointAzimuth", tpointAzimuth, DataTypes.StringType); + spark.udf().register("tpointDirection", tpointDirection, DataTypes.StringType); + spark.udf().register("tpointCumulativeLength", tpointCumulativeLength, DataTypes.StringType); + spark.udf().register("tgeoTraversedArea", tgeoTraversedArea, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/BoolOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/BoolOpsUDFs.java new file mode 100644 index 00000000..57b23521 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/BoolOpsUDFs.java @@ -0,0 +1,385 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for temporal boolean AND/OR operations on tbool. + * + * Spark SQL cannot register two UDFs with the same name but different + * argument types, so the three arities of tand/tor are registered with + * type-qualified names: + * + * tandBool(tbool, bool) → tand_tbool_bool + * tandBoolTbool(bool, tbool) → tand_bool_tbool + * tandTboolTbool(tbool,tbool)→ tand_tbool_tbool + * + * (Likewise for tor.) + * + * All temporal inputs and outputs use hex-WKB string encoding. + * + * MEOS function authority: meos/include/meos.h (028_tbool_boolops) + */ +public final class BoolOpsUDFs { + + private BoolOpsUDFs() {} + + private static String hexOut(Pointer r) { + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } + + // ------------------------------------------------------------------ + // tnot: temporal NOT + // MEOS: tnot_tbool(const Temporal *) → Temporal * + // ------------------------------------------------------------------ + + public static final UDF1 tnotTbool = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tnot_tbool(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + // ------------------------------------------------------------------ + // tand: temporal AND + // MEOS: tand_tbool_bool / tand_bool_tbool / tand_tbool_tbool + // ------------------------------------------------------------------ + + // tandBool(tbool_hex, bool) → tbool hex-WKB + public static final UDF2 tandBool = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tand_tbool_bool(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + // tandBoolTbool(bool, tbool_hex) → tbool hex-WKB + public static final UDF2 tandBoolTbool = + (v, s) -> { + if (v == null || s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tand_bool_tbool(v, ptr)); + } finally { MeosMemory.free(ptr); } + }; + + // tandTboolTbool(tbool1_hex, tbool2_hex) → tbool hex-WKB + public static final UDF2 tandTboolTbool = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.tand_tbool_tbool(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // tor: temporal OR + // MEOS: tor_tbool_bool / tor_bool_tbool / tor_tbool_tbool + // ------------------------------------------------------------------ + + // torBool(tbool_hex, bool) → tbool hex-WKB + public static final UDF2 torBool = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tor_tbool_bool(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + // torBoolTbool(bool, tbool_hex) → tbool hex-WKB + public static final UDF2 torBoolTbool = + (v, s) -> { + if (v == null || s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tor_bool_tbool(v, ptr)); + } finally { MeosMemory.free(ptr); } + }; + + // torTboolTbool(tbool1_hex, tbool2_hex) → tbool hex-WKB + public static final UDF2 torTboolTbool = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.tor_tbool_tbool(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // Temporal boolean accessor + // ------------------------------------------------------------------ + + // tboolWhenTrue(tbool_hex) → tstzspanset hex-WKB + // Returns the periods when the tbool is true. + // MEOS: tbool_when_true(const Temporal *) → SpanSet * + public static final UDF1 tboolWhenTrue = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.tbool_when_true(ptr); + if (r == null) return null; + try { + return functions.spanset_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Temporal comparison operators (temporal × temporal → tbool hex-WKB) + // + // MEOS: teq/tne/tlt/tle/tgt/tge_temporal_temporal meos.h + // ------------------------------------------------------------------ + + public static final UDF2 teqTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.teq_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 tneTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.tne_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 tltTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.tlt_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 tleTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.tle_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 tgtTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.tgt_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + public static final UDF2 tgeTemporalTemporal = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + Pointer r = functions.tge_temporal_temporal(p1, p2); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(p2); + } + } finally { + MeosMemory.free(p1); + } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // tnot + spark.udf().register("tnotTbool", tnotTbool, DataTypes.StringType); + // tand + spark.udf().register("tandBool", tandBool, DataTypes.StringType); + spark.udf().register("tandBoolTbool", tandBoolTbool, DataTypes.StringType); + spark.udf().register("tandTboolTbool", tandTboolTbool, DataTypes.StringType); + // tor + spark.udf().register("torBool", torBool, DataTypes.StringType); + spark.udf().register("torBoolTbool", torBoolTbool, DataTypes.StringType); + spark.udf().register("torTboolTbool", torTboolTbool, DataTypes.StringType); + // tbool accessor + spark.udf().register("tboolWhenTrue", tboolWhenTrue, DataTypes.StringType); + // temporal comparison operators + spark.udf().register("teqTemporalTemporal", teqTemporalTemporal, DataTypes.StringType); + spark.udf().register("tneTemporalTemporal", tneTemporalTemporal, DataTypes.StringType); + spark.udf().register("tltTemporalTemporal", tltTemporalTemporal, DataTypes.StringType); + spark.udf().register("tleTemporalTemporal", tleTemporalTemporal, DataTypes.StringType); + spark.udf().register("tgtTemporalTemporal", tgtTemporalTemporal, DataTypes.StringType); + spark.udf().register("tgeTemporalTemporal", tgeTemporalTemporal, DataTypes.StringType); + + // MobilityDB SQL bare-name aliases for tbool boolops + spark.udf().register("tboolNot", tnotTbool, DataTypes.StringType); + spark.udf().register("tboolAnd", tandTboolTbool, DataTypes.StringType); + spark.udf().register("tboolOr", torTboolTbool, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/BucketUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/BucketUDFs.java new file mode 100644 index 00000000..6165034b --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/BucketUDFs.java @@ -0,0 +1,70 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.mobilitydb.spark.MeosNative; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for bucketing scalar values onto a regular grid — used to + * implement time-windowed aggregations and value histograms. + * + * MEOS: float_bucket / int_bucket round their input down to the nearest + * bucket boundary, given a bucket size and an origin offset. + * + * floatBucket(7.3, 1.0, 0.0) = 7.0 // bucket [7.0, 8.0) + * intBucket(17, 5, 0) = 15 // bucket [15, 20) + */ +public final class BucketUDFs { + + private BucketUDFs() {} + + // floatBucket(value DOUBLE, size DOUBLE, origin DOUBLE) → DOUBLE + // MEOS: float_get_bin (renamed from float_bucket; not in JMEOS-1.4) + public static final UDF3 floatBucket = + (value, size, origin) -> { + if (value == null || size == null || origin == null) return null; + MeosThread.ensureReady(); + return MeosNative.INSTANCE.float_get_bin(value, size, origin); + }; + + // intBucket(value INT, size INT, origin INT) → INT + // MEOS: int_get_bin (renamed from int_bucket; not in JMEOS-1.4) + public static final UDF3 intBucket = + (value, size, origin) -> { + if (value == null || size == null || origin == null) return null; + MeosThread.ensureReady(); + return MeosNative.INSTANCE.int_get_bin(value, size, origin); + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("floatBucket", floatBucket, DataTypes.DoubleType); + spark.udf().register("intBucket", intBucket, DataTypes.IntegerType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/ConstructorUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/ConstructorUDFs.java new file mode 100644 index 00000000..45db9ee5 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/ConstructorUDFs.java @@ -0,0 +1,483 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for constructing temporal and span types from text literals. + * + * All UDFs accept a WKT/text literal and return the internal hex-WKB + * representation used throughout MobilitySpark. This matches the MobilityDuck + * constructor surface (tstzspan, intspan, tint, tfloat, …). + * + * Storage convention: temporal values and span/set values are stored as + * hex-WKB strings produced by temporal_as_hexwkb / span_as_hexwkb. + * + * MEOS function authority: meos/include/meos.h and meos/include/meos_geo.h + */ +public final class ConstructorUDFs { + + private ConstructorUDFs() {} + + // ------------------------------------------------------------------ + // Temporal type constructors: text literal → hex-WKB STRING + // ------------------------------------------------------------------ + + // tint("[1@2020-01-01, 2@2020-01-02]") → hex-WKB + // MEOS: tint_in(const char *) → Temporal * + public static final UDF1 tint = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tint_in(s); + if (ptr == null) return null; + return functions.temporal_as_hexwkb(ptr, (byte) 0); + }; + + // tfloat("1.5@2020-01-01") → hex-WKB + // MEOS: tfloat_in(const char *) → Temporal * + public static final UDF1 tfloat = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tfloat_in(s); + if (ptr == null) return null; + return functions.temporal_as_hexwkb(ptr, (byte) 0); + }; + + // tbool("true@2020-01-01") → hex-WKB + // MEOS: tbool_in(const char *) → Temporal * + public static final UDF1 tbool = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tbool_in(s); + if (ptr == null) return null; + return functions.temporal_as_hexwkb(ptr, (byte) 0); + }; + + // ttext("hello@2020-01-01") → hex-WKB + // MEOS: ttext_in(const char *) → Temporal * + public static final UDF1 ttext = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.ttext_in(s); + if (ptr == null) return null; + return functions.temporal_as_hexwkb(ptr, (byte) 0); + }; + + // tgeogpoint("POINT(4.35 50.85)@2020-01-01") → hex-WKB + // MEOS: tgeogpoint_in(const char *) → Temporal * + public static final UDF1 tgeogpoint = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tgeogpoint_in(s); + if (ptr == null) return null; + return functions.temporal_as_hexwkb(ptr, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Span type constructors: text literal → hex-WKB STRING + // ------------------------------------------------------------------ + + // tstzspan("[2020-01-01, 2020-01-02)") → hex-WKB + // MEOS: tstzspan_in(const char *) → Span * + public static final UDF1 tstzspan = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tstzspan_in(s); + if (ptr == null) return null; + return functions.span_as_hexwkb(ptr, (byte) 0); + }; + + // tstzspanset("{[2020-01-01, 2020-01-02), [2020-03-01, 2020-04-01)}") → hex-WKB + // MEOS: tstzspanset_in(const char *) → SpanSet * + public static final UDF1 tstzspanset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tstzspanset_in(s); + if (ptr == null) return null; + return functions.spanset_as_hexwkb(ptr, (byte) 0); + }; + + // intspan("[1, 10)") → hex-WKB + // MEOS: intspan_in(const char *) → Span * + public static final UDF1 intspan = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.intspan_in(s); + if (ptr == null) return null; + return functions.span_as_hexwkb(ptr, (byte) 0); + }; + + // floatspan("[1.0, 10.0)") → hex-WKB + // MEOS: floatspan_in(const char *) → Span * + public static final UDF1 floatspan = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.floatspan_in(s); + if (ptr == null) return null; + return functions.span_as_hexwkb(ptr, (byte) 0); + }; + + // datespan("[2020-01-01, 2020-01-31)") → hex-WKB + // MEOS: datespan_in(const char *) → Span * + public static final UDF1 datespan = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.datespan_in(s); + if (ptr == null) return null; + return functions.span_as_hexwkb(ptr, (byte) 0); + }; + + // datespanset("{[2020-01-01, 2020-01-31), [2020-06-01, 2020-06-30)}") → hex-WKB + // MEOS: datespanset_in(const char *) → SpanSet * + public static final UDF1 datespanset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.datespanset_in(s); + if (ptr == null) return null; + return functions.spanset_as_hexwkb(ptr, (byte) 0); + }; + + // intset("{1, 2, 3, 4}") → hex-WKB + // MEOS: intset_in(const char *) → Set * + public static final UDF1 intset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.intset_in(s); + if (ptr == null) return null; + return functions.set_as_hexwkb(ptr, (byte) 0); + }; + + // floatset("{1.1, 2.2, 3.3}") → hex-WKB + // MEOS: floatset_in(const char *) → Set * + public static final UDF1 floatset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.floatset_in(s); + if (ptr == null) return null; + return functions.set_as_hexwkb(ptr, (byte) 0); + }; + + // tstzset("{2020-01-01, 2020-02-01, 2020-03-01}") → hex-WKB + // MEOS: tstzset_in(const char *) → Set * + public static final UDF1 tstzset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tstzset_in(s); + if (ptr == null) return null; + return functions.set_as_hexwkb(ptr, (byte) 0); + }; + + // textset("{hello, world}") → hex-WKB + // MEOS: textset_in(const char *) → Set * + public static final UDF1 textset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.textset_in(s); + if (ptr == null) return null; + return functions.set_as_hexwkb(ptr, (byte) 0); + }; + + // bigintset("{1000, 2000, 3000}") → hex-WKB + // MEOS: bigintset_in(const char *) → Set * + public static final UDF1 bigintset = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.bigintset_in(s); + if (ptr == null) return null; + return functions.set_as_hexwkb(ptr, (byte) 0); + }; + + // stbox("STBOX X((1,2),(3,4))") → hex-WKB + // MEOS: stbox_in(const char *) → STBox * + public static final UDF1 stbox = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.stbox_in(s); + if (ptr == null) return null; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(ptr, (byte) 0, sizeOut); + }; + + // tbox("TBOX T([2020-01-01,2020-01-02))") → hex-WKB + // MEOS: tbox_in(const char *) → TBox * + public static final UDF1 tbox = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.tbox_in(s); + if (ptr == null) return null; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(ptr, (byte) 0, sizeOut); + }; + + // ------------------------------------------------------------------ + // MFJSON constructors (JSON string in → hex-WKB out) + // + // MEOS: tbool_from_mfjson, tint_from_mfjson, tfloat_from_mfjson, + // ttext_from_mfjson (meos.h) + // tgeompoint_from_mfjson, tgeogpoint_from_mfjson (meos_geo.h) + // ------------------------------------------------------------------ + + public static final UDF1 tboolFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tbool_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + public static final UDF1 tintFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tint_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + public static final UDF1 tfloatFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tfloat_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + public static final UDF1 ttextFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.ttext_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + public static final UDF1 tgeompointFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tgeompoint_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + public static final UDF1 tgeogpointFromMfjson = + (json) -> { + if (json == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tgeogpoint_from_mfjson(json); + if (p == null) return null; + return functions.temporal_as_hexwkb(p, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Constant temporal constructors (scalar value + reference temporal) + // + // Each function creates a temporal that is constant at the given value + // over the same time structure as the reference temporal. + // + // MEOS: tbool_from_base_temp, tint_from_base_temp, tfloat_from_base_temp, + // ttext_from_base_temp (meos.h) + // ------------------------------------------------------------------ + + // tboolFromBaseTemp(val BOOLEAN, refHex STRING) → STRING + public static final UDF2 tboolFromBaseTemp = + (val, refHex) -> { + if (val == null || refHex == null) return null; + MeosThread.ensureReady(); + Pointer ref = functions.temporal_from_hexwkb(refHex); + if (ref == null) return null; + try { + Pointer result = functions.tbool_from_base_temp(val, ref); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ref); + } + }; + + // tintFromBaseTemp(val INT, refHex STRING) → STRING + public static final UDF2 tintFromBaseTemp = + (val, refHex) -> { + if (val == null || refHex == null) return null; + MeosThread.ensureReady(); + Pointer ref = functions.temporal_from_hexwkb(refHex); + if (ref == null) return null; + try { + Pointer result = functions.tint_from_base_temp(val, ref); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ref); + } + }; + + // tfloatFromBaseTemp(val DOUBLE, refHex STRING) → STRING + public static final UDF2 tfloatFromBaseTemp = + (val, refHex) -> { + if (val == null || refHex == null) return null; + MeosThread.ensureReady(); + Pointer ref = functions.temporal_from_hexwkb(refHex); + if (ref == null) return null; + try { + Pointer result = functions.tfloat_from_base_temp(val, ref); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ref); + } + }; + + // ttextFromBaseTemp(val STRING, refHex STRING) → STRING + // Uses ttext_in + ttext_value_n to materialise a text* from val. + public static final UDF2 ttextFromBaseTemp = + (val, refHex) -> { + if (val == null || refHex == null) return null; + MeosThread.ensureReady(); + // Wrap val in a single-instant ttext so we can extract a text* from it. + Pointer dummyTtext = functions.ttext_in(val + "@2000-01-01 00:00:00+00"); + if (dummyTtext == null) return null; + Pointer textPtr = null; + Pointer ref = null; + Pointer result = null; + try { + textPtr = functions.ttext_value_n(dummyTtext, 1); + if (textPtr == null) return null; + ref = functions.temporal_from_hexwkb(refHex); + if (ref == null) return null; + result = functions.ttext_from_base_temp(textPtr, ref); + if (result == null) return null; + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(dummyTtext); + if (textPtr != null) MeosMemory.free(textPtr); + if (ref != null) MeosMemory.free(ref); + if (result != null) MeosMemory.free(result); + } + }; + + // tpointFromBaseTemp(geoWkt STRING, refHex STRING) → STRING + // Creates a constant tpoint that takes the temporal structure from refHex + // and uses the given geometry (WKT) as the base value. + // MEOS: tpoint_from_base_temp(const GSERIALIZED *, const Temporal *) → Temporal * + public static final UDF2 tpointFromBaseTemp = + (geoWkt, refHex) -> { + if (geoWkt == null || refHex == null) return null; + MeosThread.ensureReady(); + Pointer gptr = functions.geo_from_text(geoWkt, 0); + if (gptr == null) return null; + try { + Pointer ref = functions.temporal_from_hexwkb(refHex); + if (ref == null) return null; + try { + Pointer result = functions.tpoint_from_base_temp(gptr, ref); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ref); + } + } finally { + MeosMemory.free(gptr); + } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("tint", tint, DataTypes.StringType); + spark.udf().register("tfloat", tfloat, DataTypes.StringType); + spark.udf().register("tbool", tbool, DataTypes.StringType); + spark.udf().register("ttext", ttext, DataTypes.StringType); + spark.udf().register("tgeogpoint", tgeogpoint, DataTypes.StringType); + spark.udf().register("tstzspan", tstzspan, DataTypes.StringType); + spark.udf().register("tstzspanset", tstzspanset, DataTypes.StringType); + spark.udf().register("intspan", intspan, DataTypes.StringType); + spark.udf().register("floatspan", floatspan, DataTypes.StringType); + spark.udf().register("datespan", datespan, DataTypes.StringType); + spark.udf().register("datespanset", datespanset, DataTypes.StringType); + spark.udf().register("intset", intset, DataTypes.StringType); + spark.udf().register("floatset", floatset, DataTypes.StringType); + spark.udf().register("tstzset", tstzset, DataTypes.StringType); + spark.udf().register("textset", textset, DataTypes.StringType); + spark.udf().register("bigintset", bigintset, DataTypes.StringType); + spark.udf().register("stbox", stbox, DataTypes.StringType); + spark.udf().register("tbox", tbox, DataTypes.StringType); + spark.udf().register("tboolFromMfjson", tboolFromMfjson, DataTypes.StringType); + spark.udf().register("tintFromMfjson", tintFromMfjson, DataTypes.StringType); + spark.udf().register("tfloatFromMfjson", tfloatFromMfjson, DataTypes.StringType); + spark.udf().register("ttextFromMfjson", ttextFromMfjson, DataTypes.StringType); + spark.udf().register("tgeompointFromMfjson",tgeompointFromMfjson,DataTypes.StringType); + spark.udf().register("tgeogpointFromMfjson",tgeogpointFromMfjson,DataTypes.StringType); + // Constant temporal constructors + spark.udf().register("tboolFromBaseTemp", tboolFromBaseTemp, DataTypes.StringType); + spark.udf().register("tintFromBaseTemp", tintFromBaseTemp, DataTypes.StringType); + spark.udf().register("tfloatFromBaseTemp", tfloatFromBaseTemp, DataTypes.StringType); + spark.udf().register("ttextFromBaseTemp", ttextFromBaseTemp, DataTypes.StringType); + spark.udf().register("tpointFromBaseTemp", tpointFromBaseTemp, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/IOAliasUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/IOAliasUDFs.java new file mode 100644 index 00000000..e368e650 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/IOAliasUDFs.java @@ -0,0 +1,431 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +import java.util.HexFormat; + +/** + * Spark SQL UDFs for typed alternative I/O constructors of set, span, and + * spanset types. MobilityDB SQL exposes typed names like + * `intsetFromHexWKB`, `floatspanFromHexWKB` etc. for type-safety in the + * SQL layer; in MobilitySpark a single generic constructor suffices since + * the WKB carries the element type, but we register typed aliases for + * MobilityDB SQL parity. + * + * MEOS function authority: meos/include/meos.h — set_from_hexwkb, + * span_from_hexwkb, spanset_from_hexwkb (generic). + */ +public final class IOAliasUDFs { + + private IOAliasUDFs() {} + + // ------------------------------------------------------------------ + // Generic helpers — round-trip a hex-WKB through deserializer + + // re-serializer to produce a normalised hex form (also validates it). + // ------------------------------------------------------------------ + + private static UDF1 setRoundtrip() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.set_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 spanRoundtrip() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { return functions.span_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 spansetRoundtrip() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.spanset_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 temporalRoundtrip() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 mfjsonToHex(java.util.function.Function ctor) { + return mfjson -> { + if (mfjson == null) return null; + MeosThread.ensureReady(); + Pointer p = ctor.apply(mfjson); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + // ------------------------------------------------------------------ + // Set typed FromHexWKB + // ------------------------------------------------------------------ + + public static final UDF1 intsetFromHexWKB = setRoundtrip(); + public static final UDF1 bigintsetFromHexWKB = setRoundtrip(); + public static final UDF1 floatsetFromHexWKB = setRoundtrip(); + public static final UDF1 textsetFromHexWKB = setRoundtrip(); + public static final UDF1 tstzsetFromHexWKB = setRoundtrip(); + public static final UDF1 datesetFromHexWKB = setRoundtrip(); + + // ------------------------------------------------------------------ + // Span typed FromHexWKB + // ------------------------------------------------------------------ + + public static final UDF1 intspanFromHexWKB = spanRoundtrip(); + public static final UDF1 bigintspanFromHexWKB = spanRoundtrip(); + public static final UDF1 floatspanFromHexWKB = spanRoundtrip(); + public static final UDF1 tstzspanFromHexWKB = spanRoundtrip(); + public static final UDF1 datespanFromHexWKB = spanRoundtrip(); + + // ------------------------------------------------------------------ + // Spanset typed FromHexWKB + // ------------------------------------------------------------------ + + public static final UDF1 intspansetFromHexWKB = spansetRoundtrip(); + public static final UDF1 bigintspansetFromHexWKB = spansetRoundtrip(); + public static final UDF1 floatspansetFromHexWKB = spansetRoundtrip(); + public static final UDF1 tstzspansetFromHexWKB = spansetRoundtrip(); + public static final UDF1 datespansetFromHexWKB = spansetRoundtrip(); + + // ------------------------------------------------------------------ + // Temporal scalar typed FromHexWKB (tbool/tint/tfloat/ttext) + // ------------------------------------------------------------------ + + public static final UDF1 tboolFromHexWKB = temporalRoundtrip(); + public static final UDF1 tintFromHexWKB = temporalRoundtrip(); + public static final UDF1 tfloatFromHexWKB = temporalRoundtrip(); + public static final UDF1 ttextFromHexWKB = temporalRoundtrip(); + + // ------------------------------------------------------------------ + // Temporal-geo typed FromHexEWKB (tgeometry/tgeography) + // ------------------------------------------------------------------ + + public static final UDF1 tgeometryFromHexEWKB = temporalRoundtrip(); + public static final UDF1 tgeographyFromHexEWKB = temporalRoundtrip(); + public static final UDF1 tgeompointFromHexEWKB = temporalRoundtrip(); + public static final UDF1 tgeogpointFromHexEWKB = temporalRoundtrip(); + + // ------------------------------------------------------------------ + // Temporal-geo MFJSON constructors + // ------------------------------------------------------------------ + + public static final UDF1 tgeometryFromMFJSON = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeometry_from_mfjson); + public static final UDF1 tgeographyFromMFJSON = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeography_from_mfjson); + public static final UDF1 tgeompointFromMFJSON = mfjsonToHex(functions::tgeompoint_from_mfjson); + public static final UDF1 tgeogpointFromMFJSON = mfjsonToHex(functions::tgeogpoint_from_mfjson); + + // ------------------------------------------------------------------ + // Temporal scalar text constructors (FromText / FromEWKT) + // ------------------------------------------------------------------ + + public static final UDF1 tboolFromText = mfjsonToHex(functions::tbool_in); + public static final UDF1 tintFromText = mfjsonToHex(functions::tint_in); + public static final UDF1 tfloatFromText = mfjsonToHex(functions::tfloat_in); + public static final UDF1 ttextFromText = mfjsonToHex(functions::ttext_in); + + // Geo temporal text/EWKT constructors + public static final UDF1 tgeompointFromText = mfjsonToHex(functions::tgeompoint_in); + public static final UDF1 tgeogpointFromText = mfjsonToHex(functions::tgeogpoint_in); + public static final UDF1 tgeompointFromEWKT = mfjsonToHex(functions::tgeompoint_in); + public static final UDF1 tgeogpointFromEWKT = mfjsonToHex(functions::tgeogpoint_in); + public static final UDF1 tgeometryFromText = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeometry_in); + public static final UDF1 tgeographyFromText = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeography_in); + public static final UDF1 tgeometryFromEWKT = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeometry_in); + public static final UDF1 tgeographyFromEWKT = mfjsonToHex(org.mobilitydb.spark.MeosNative.INSTANCE::tgeography_in); + + // ------------------------------------------------------------------ + // Binary I/O — bytes ↔ temporal via hex round-trip + // (matches the SpanUDFs pattern: byte[] → hex → from_hexwkb → as_hexwkb) + // ------------------------------------------------------------------ + + private static UDF1 temporalFromBinary() { + return bytes -> { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + public static final UDF1 tboolFromBinary = temporalFromBinary(); + public static final UDF1 tintFromBinary = temporalFromBinary(); + public static final UDF1 tfloatFromBinary = temporalFromBinary(); + public static final UDF1 ttextFromBinary = temporalFromBinary(); + public static final UDF1 tgeompointFromBinary = temporalFromBinary(); + public static final UDF1 tgeogpointFromBinary = temporalFromBinary(); + public static final UDF1 tgeometryFromBinary = temporalFromBinary(); + public static final UDF1 tgeographyFromBinary = temporalFromBinary(); + // EWKB and WKB go through the same generic constructor. + public static final UDF1 tgeompointFromEWKB = temporalFromBinary(); + public static final UDF1 tgeogpointFromEWKB = temporalFromBinary(); + public static final UDF1 tgeometryFromEWKB = temporalFromBinary(); + public static final UDF1 tgeographyFromEWKB = temporalFromBinary(); + + // asBinary / asEWKB: hex → byte[] inverse round-trip + public static final UDF1 asBinary = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + return HexFormat.of().parseHex(hex); + }; + + public static final UDF1 asEWKB = asBinary; + + // asHexEWKB: re-emit hex with WKB_EXTENDED (variant 4) so SRID is preserved + public static final UDF1 asHexEWKB = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 4); } + finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Geoset typed I/O aliases (geomset / geogset) + // ------------------------------------------------------------------ + + private static UDF1 geomsetTextCtor() { + return wkt -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.geomset_in(wkt); + if (p == null) return null; + try { return functions.set_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 geogsetTextCtor() { + return wkt -> { + if (wkt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.geogset_in(wkt); + if (p == null) return null; + try { return functions.set_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + private static UDF1 setFromBinary() { + return bytes -> { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.set_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + } + + public static final UDF1 geomsetFromText = geomsetTextCtor(); + public static final UDF1 geogsetFromText = geogsetTextCtor(); + public static final UDF1 geomsetFromEWKT = geomsetTextCtor(); + public static final UDF1 geogsetFromEWKT = geogsetTextCtor(); + public static final UDF1 geomsetFromHexWKB = setRoundtrip(); + public static final UDF1 geogsetFromHexWKB = setRoundtrip(); + public static final UDF1 geomsetFromBinary = setFromBinary(); + public static final UDF1 geogsetFromBinary = setFromBinary(); + public static final UDF1 geomsetFromEWKB = setFromBinary(); + public static final UDF1 geogsetFromEWKB = setFromBinary(); + + // ------------------------------------------------------------------ + // TBox typed I/O aliases — generic tbox_from_hexwkb covers all. + // ------------------------------------------------------------------ + + public static final UDF1 tboxFromHexWKB = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tbox_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer sizeOut = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 tboxFromBinary = + bytes -> { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer p = functions.tbox_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer sizeOut = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // STBox typed I/O aliases + // ------------------------------------------------------------------ + + public static final UDF1 stboxFromHexWKB = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.stbox_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer sizeOut = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 stboxFromBinary = + bytes -> { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer p = functions.stbox_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer sizeOut = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(p, (byte) 0, sizeOut); + } finally { MeosMemory.free(p); } + }; + + public static void registerAll(SparkSession spark) { + // Set + spark.udf().register("intsetFromHexWKB", intsetFromHexWKB, DataTypes.StringType); + spark.udf().register("bigintsetFromHexWKB", bigintsetFromHexWKB, DataTypes.StringType); + spark.udf().register("floatsetFromHexWKB", floatsetFromHexWKB, DataTypes.StringType); + spark.udf().register("textsetFromHexWKB", textsetFromHexWKB, DataTypes.StringType); + spark.udf().register("tstzsetFromHexWKB", tstzsetFromHexWKB, DataTypes.StringType); + spark.udf().register("datesetFromHexWKB", datesetFromHexWKB, DataTypes.StringType); + // Span + spark.udf().register("intspanFromHexWKB", intspanFromHexWKB, DataTypes.StringType); + spark.udf().register("bigintspanFromHexWKB", bigintspanFromHexWKB, DataTypes.StringType); + spark.udf().register("floatspanFromHexWKB", floatspanFromHexWKB, DataTypes.StringType); + spark.udf().register("tstzspanFromHexWKB", tstzspanFromHexWKB, DataTypes.StringType); + spark.udf().register("datespanFromHexWKB", datespanFromHexWKB, DataTypes.StringType); + // Spanset + spark.udf().register("intspansetFromHexWKB", intspansetFromHexWKB, DataTypes.StringType); + spark.udf().register("bigintspansetFromHexWKB", bigintspansetFromHexWKB, DataTypes.StringType); + spark.udf().register("floatspansetFromHexWKB", floatspansetFromHexWKB, DataTypes.StringType); + spark.udf().register("tstzspansetFromHexWKB", tstzspansetFromHexWKB, DataTypes.StringType); + spark.udf().register("datespansetFromHexWKB", datespansetFromHexWKB, DataTypes.StringType); + // Temporal scalar + spark.udf().register("tboolFromHexWKB", tboolFromHexWKB, DataTypes.StringType); + spark.udf().register("tintFromHexWKB", tintFromHexWKB, DataTypes.StringType); + spark.udf().register("tfloatFromHexWKB", tfloatFromHexWKB, DataTypes.StringType); + spark.udf().register("ttextFromHexWKB", ttextFromHexWKB, DataTypes.StringType); + // Temporal-geo + spark.udf().register("tgeometryFromHexEWKB", tgeometryFromHexEWKB, DataTypes.StringType); + spark.udf().register("tgeographyFromHexEWKB", tgeographyFromHexEWKB, DataTypes.StringType); + spark.udf().register("tgeompointFromHexEWKB", tgeompointFromHexEWKB, DataTypes.StringType); + spark.udf().register("tgeogpointFromHexEWKB", tgeogpointFromHexEWKB, DataTypes.StringType); + spark.udf().register("tgeometryFromMFJSON", tgeometryFromMFJSON, DataTypes.StringType); + spark.udf().register("tgeographyFromMFJSON", tgeographyFromMFJSON, DataTypes.StringType); + spark.udf().register("tgeompointFromMFJSON", tgeompointFromMFJSON, DataTypes.StringType); + spark.udf().register("tgeogpointFromMFJSON", tgeogpointFromMFJSON, DataTypes.StringType); + // Temporal scalar text + spark.udf().register("tboolFromText", tboolFromText, DataTypes.StringType); + spark.udf().register("tintFromText", tintFromText, DataTypes.StringType); + spark.udf().register("tfloatFromText", tfloatFromText, DataTypes.StringType); + spark.udf().register("ttextFromText", ttextFromText, DataTypes.StringType); + // Geo temporal text/EWKT + spark.udf().register("tgeompointFromText", tgeompointFromText, DataTypes.StringType); + spark.udf().register("tgeogpointFromText", tgeogpointFromText, DataTypes.StringType); + spark.udf().register("tgeompointFromEWKT", tgeompointFromEWKT, DataTypes.StringType); + spark.udf().register("tgeogpointFromEWKT", tgeogpointFromEWKT, DataTypes.StringType); + spark.udf().register("tgeometryFromText", tgeometryFromText, DataTypes.StringType); + spark.udf().register("tgeographyFromText", tgeographyFromText, DataTypes.StringType); + spark.udf().register("tgeometryFromEWKT", tgeometryFromEWKT, DataTypes.StringType); + spark.udf().register("tgeographyFromEWKT", tgeographyFromEWKT, DataTypes.StringType); + // Binary I/O + spark.udf().register("tboolFromBinary", tboolFromBinary, DataTypes.StringType); + spark.udf().register("tintFromBinary", tintFromBinary, DataTypes.StringType); + spark.udf().register("tfloatFromBinary", tfloatFromBinary, DataTypes.StringType); + spark.udf().register("ttextFromBinary", ttextFromBinary, DataTypes.StringType); + spark.udf().register("tgeompointFromBinary", tgeompointFromBinary, DataTypes.StringType); + spark.udf().register("tgeogpointFromBinary", tgeogpointFromBinary, DataTypes.StringType); + spark.udf().register("tgeometryFromBinary", tgeometryFromBinary, DataTypes.StringType); + spark.udf().register("tgeographyFromBinary", tgeographyFromBinary, DataTypes.StringType); + spark.udf().register("tgeompointFromEWKB", tgeompointFromEWKB, DataTypes.StringType); + spark.udf().register("tgeogpointFromEWKB", tgeogpointFromEWKB, DataTypes.StringType); + spark.udf().register("tgeometryFromEWKB", tgeometryFromEWKB, DataTypes.StringType); + spark.udf().register("tgeographyFromEWKB", tgeographyFromEWKB, DataTypes.StringType); + spark.udf().register("asBinary", asBinary, DataTypes.BinaryType); + spark.udf().register("asEWKB", asEWKB, DataTypes.BinaryType); + spark.udf().register("asHexEWKB", asHexEWKB, DataTypes.StringType); + // Geoset typed I/O + spark.udf().register("geomsetFromText", geomsetFromText, DataTypes.StringType); + spark.udf().register("geogsetFromText", geogsetFromText, DataTypes.StringType); + spark.udf().register("geomsetFromEWKT", geomsetFromEWKT, DataTypes.StringType); + spark.udf().register("geogsetFromEWKT", geogsetFromEWKT, DataTypes.StringType); + spark.udf().register("geomsetFromHexWKB", geomsetFromHexWKB, DataTypes.StringType); + spark.udf().register("geogsetFromHexWKB", geogsetFromHexWKB, DataTypes.StringType); + spark.udf().register("geomsetFromBinary", geomsetFromBinary, DataTypes.StringType); + spark.udf().register("geogsetFromBinary", geogsetFromBinary, DataTypes.StringType); + spark.udf().register("geomsetFromEWKB", geomsetFromEWKB, DataTypes.StringType); + spark.udf().register("geogsetFromEWKB", geogsetFromEWKB, DataTypes.StringType); + // TBox typed I/O + spark.udf().register("tboxFromHexWKB", tboxFromHexWKB, DataTypes.StringType); + spark.udf().register("tboxFromBinary", tboxFromBinary, DataTypes.StringType); + // STBox typed I/O + spark.udf().register("stboxFromHexWKB", stboxFromHexWKB, DataTypes.StringType); + spark.udf().register("stboxFromBinary", stboxFromBinary, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/MathUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/MathUDFs.java new file mode 100644 index 00000000..b4914033 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/MathUDFs.java @@ -0,0 +1,353 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for arithmetic on tnumber (tint / tfloat). + * + * Three groups: + * 1. Unary analytics: abs, deltaValue, angularDifference (on tnumber), + * angularDifference (on tpoint → tfloat). + * 2. Scalar arithmetic: add/sub/mult/div of tnumber with a Java scalar + * (tint+int, tfloat+double). + * 3. Temporal arithmetic: add/sub/mult/div of two tnumbers. + * + * All temporal inputs and outputs use hex-WKB string encoding. + * + * MEOS function authority: meos/include/meos.h (026_tnumber_mathfuncs) + */ +public final class MathUDFs { + + private MathUDFs() {} + + private static String hexOut(Pointer r) { + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } + + // ------------------------------------------------------------------ + // Unary analytics (hex-WKB in, hex-WKB out) + // + // MEOS: tnumber_abs, tnumber_delta_value, tnumber_angular_difference, + // tpoint_angular_difference (→ tfloat hex-WKB) + // ------------------------------------------------------------------ + + public static final UDF1 tnumberAbs = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tnumber_abs(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF1 tnumberDeltaValue = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tnumber_delta_value(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF1 tnumberAngularDifference = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tnumber_angular_difference(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF1 tpointAngularDifference = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tpoint_angular_difference(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + // ------------------------------------------------------------------ + // Transcendental functions (tfloat → tfloat) + // + // MEOS: tfloat_exp / tfloat_ln / tfloat_log10 + // ------------------------------------------------------------------ + + public static final UDF1 tfloatExp = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tfloat_exp(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF1 tfloatLn = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tfloat_ln(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF1 tfloatLog10 = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.tfloat_log10(ptr)); + } finally { MeosMemory.free(ptr); } + }; + + // ------------------------------------------------------------------ + // Scalar arithmetic: tint OP int (hex-WKB in, int scalar, hex-WKB out) + // + // MEOS: add_tint_int / sub_tint_int / mult_tint_int / div_tint_int + // ------------------------------------------------------------------ + + public static final UDF2 addTintInt = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.add_tint_int(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 subTintInt = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.sub_tint_int(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 multTintInt = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.mult_tint_int(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 divTintInt = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.div_tint_int(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + // ------------------------------------------------------------------ + // Scalar arithmetic: tfloat OP double (hex-WKB in, double scalar, hex-WKB out) + // + // MEOS: add_tfloat_float / sub_tfloat_float / mult_tfloat_float / div_tfloat_float + // ------------------------------------------------------------------ + + public static final UDF2 addTfloatFloat = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.add_tfloat_float(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 subTfloatFloat = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.sub_tfloat_float(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 multTfloatFloat = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.mult_tfloat_float(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + public static final UDF2 divTfloatFloat = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return hexOut(functions.div_tfloat_float(ptr, v)); + } finally { MeosMemory.free(ptr); } + }; + + // ------------------------------------------------------------------ + // Temporal arithmetic: tnumber OP tnumber (hex-WKB in, hex-WKB out) + // + // MEOS: add_tnumber_tnumber / sub_tnumber_tnumber / + // mult_tnumber_tnumber / div_tnumber_tnumber + // + // Both tnumbers must have the same value type (tint+tint or tfloat+tfloat). + // ------------------------------------------------------------------ + + public static final UDF2 addTnumberTnumber = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.add_tnumber_tnumber(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 subTnumberTnumber = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.sub_tnumber_tnumber(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 multTnumberTnumber = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.mult_tnumber_tnumber(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 divTnumberTnumber = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + return hexOut(functions.div_tnumber_tnumber(p1, p2)); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // unary analytics + spark.udf().register("tnumberAbs", tnumberAbs, DataTypes.StringType); + spark.udf().register("tnumberDeltaValue", tnumberDeltaValue, DataTypes.StringType); + spark.udf().register("tnumberAngularDifference", tnumberAngularDifference, DataTypes.StringType); + spark.udf().register("tpointAngularDifference", tpointAngularDifference, DataTypes.StringType); + // transcendental + spark.udf().register("tfloatExp", tfloatExp, DataTypes.StringType); + spark.udf().register("tfloatLn", tfloatLn, DataTypes.StringType); + spark.udf().register("tfloatLog10", tfloatLog10, DataTypes.StringType); + // tint + scalar + spark.udf().register("addTintInt", addTintInt, DataTypes.StringType); + spark.udf().register("subTintInt", subTintInt, DataTypes.StringType); + spark.udf().register("multTintInt", multTintInt, DataTypes.StringType); + spark.udf().register("divTintInt", divTintInt, DataTypes.StringType); + // tfloat + scalar + spark.udf().register("addTfloatFloat", addTfloatFloat, DataTypes.StringType); + spark.udf().register("subTfloatFloat", subTfloatFloat, DataTypes.StringType); + spark.udf().register("multTfloatFloat", multTfloatFloat, DataTypes.StringType); + spark.udf().register("divTfloatFloat", divTfloatFloat, DataTypes.StringType); + // tnumber + tnumber + spark.udf().register("addTnumberTnumber", addTnumberTnumber, DataTypes.StringType); + spark.udf().register("subTnumberTnumber", subTnumberTnumber, DataTypes.StringType); + spark.udf().register("multTnumberTnumber", multTnumberTnumber, DataTypes.StringType); + spark.udf().register("divTnumberTnumber", divTnumberTnumber, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/MoreAccessorUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/MoreAccessorUDFs.java new file mode 100644 index 00000000..68846a18 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/MoreAccessorUDFs.java @@ -0,0 +1,898 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.sql.Timestamp; +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.List; + +/** + * Spark SQL UDFs for temporal structure and value accessors not covered by + * AccessorUDFs.java or TemporalUDFs.java. + * + * Covers: subtype, instant/sequence navigation, timestampN, inclusivity flags, + * duration, type-specific valueN accessors (tbool, tfloat, ttext, tpoint), + * and tpoint geometry accessors (SRID, convex hull). + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +public final class MoreAccessorUDFs { + + private MoreAccessorUDFs() {} + + // Milliseconds from Unix epoch (1970-01-01) to PG epoch (2000-01-01). + private static final long PG_UNIX_EPOCH_OFFSET_MS = 946684800L * 1000L; + + /** Convert a raw PG-epoch microsecond value to a Spark Timestamp. */ + static Timestamp fromPgMicros(long pgMicros) { + return new Timestamp(pgMicros / 1000L + PG_UNIX_EPOCH_OFFSET_MS); + } + + // ------------------------------------------------------------------ + // Subtype + // ------------------------------------------------------------------ + + // temporalSubtype(trip STRING) → STRING ("Instant" | "Sequence" | "SequenceSet") + // MEOS: temporal_subtype(const Temporal *) → char * + public static final UDF1 temporalSubtype = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_subtype(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Instant navigation + // ------------------------------------------------------------------ + + // startInstant(trip STRING) → STRING (hex-WKB of first instant) + // MEOS: temporal_start_instant(const Temporal *) → TInstant * (owned copy) + public static final UDF1 startInstant = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_start_instant(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // endInstant(trip STRING) → STRING (hex-WKB of last instant) + // MEOS: temporal_end_instant(const Temporal *) → TInstant * (owned copy) + public static final UDF1 endInstant = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_end_instant(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // instantN(trip STRING, n INT) → STRING (hex-WKB of n-th instant, 1-based) + // MEOS: temporal_instant_n(const Temporal *, int) → TInstant * (owned copy) + public static final UDF2 instantN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_instant_n(ptr, n); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Sequence navigation + // ------------------------------------------------------------------ + + // startSequence(trip STRING) → STRING (hex-WKB of first sequence) + // MEOS: temporal_start_sequence(const Temporal *) → TSequence * (owned copy) + public static final UDF1 startSequence = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_start_sequence(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // endSequence(trip STRING) → STRING (hex-WKB of last sequence) + // MEOS: temporal_end_sequence(const Temporal *) → TSequence * (owned copy) + public static final UDF1 endSequence = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_end_sequence(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // sequenceN(trip STRING, n INT) → STRING (hex-WKB of n-th sequence, 1-based) + // MEOS: temporal_sequence_n(const Temporal *, int) → TSequence * (owned copy) + public static final UDF2 sequenceN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_sequence_n(ptr, n); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Min/max instant + // ------------------------------------------------------------------ + + // minInstant(trip STRING) → STRING (hex-WKB of instant with minimum value) + // MEOS: temporal_min_instant(const Temporal *) → TInstant * (owned copy) + public static final UDF1 minInstant = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_min_instant(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // maxInstant(trip STRING) → STRING (hex-WKB of instant with maximum value) + // MEOS: temporal_max_instant(const Temporal *) → TInstant * (owned copy) + public static final UDF1 maxInstant = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_max_instant(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Timestamp accessors + // ------------------------------------------------------------------ + + // numTimestamps(trip STRING) → INT + // MEOS: temporal_num_timestamps(const Temporal *) → int + public static final UDF1 numTimestamps = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_num_timestamps(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + // timestampN(trip STRING, n INT) → TIMESTAMP (n-th timestamp, 1-based) + // MEOS: temporal_timestamptz_n writes TimestampTz (int64) into a JNR-FFI buffer; + // the returned Pointer is JNR-FFI managed — DO NOT call MeosMemory.free on it. + public static final UDF2 timestampN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer tsPtr = functions.temporal_timestamptz_n(ptr, n); + if (tsPtr == null) return null; + return fromPgMicros(tsPtr.getLong(0)); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Inclusivity flags + // ------------------------------------------------------------------ + + // lowerInc(trip STRING) → BOOLEAN (true if the lower bound is inclusive) + // MEOS: temporal_lower_inc(const Temporal *) → int (nonzero = true) + public static final UDF1 lowerInc = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_lower_inc(ptr) != 0; + } finally { + MeosMemory.free(ptr); + } + }; + + // upperInc(trip STRING) → BOOLEAN (true if the upper bound is inclusive) + // MEOS: temporal_upper_inc(const Temporal *) → int (nonzero = true) + public static final UDF1 upperInc = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_upper_inc(ptr) != 0; + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Duration + // ------------------------------------------------------------------ + + // duration(trip STRING) → STRING (PostgreSQL interval literal, e.g. "01:30:00") + // MEOS: temporal_duration(const Temporal *, bool) → Interval * + // pg_interval_out(const Interval *) → char * + public static final UDF1 duration = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer ivPtr = functions.temporal_duration(ptr, false); + if (ivPtr == null) return null; + try { + return functions.pg_interval_out(ivPtr); + } finally { + MeosMemory.free(ivPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tbool value accessor + // ------------------------------------------------------------------ + + // tboolValueN(trip STRING, n INT) → BOOLEAN (n-th value, 1-based) + // MEOS: tbool_value_n writes bool directly into a JNR-FFI buffer; + // the returned Pointer is JNR-FFI managed — DO NOT call MeosMemory.free on it. + public static final UDF2 tboolValueN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer bPtr = functions.tbool_value_n(ptr, n); + if (bPtr == null) return null; + return bPtr.getByte(0) != 0; + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tfloat value accessor + // ------------------------------------------------------------------ + + // tfloatValueN(trip STRING, n INT) → DOUBLE (n-th value, 1-based) + // MEOS: tfloat_value_n writes double directly into a JNR-FFI buffer; + // the returned Pointer is JNR-FFI managed — DO NOT call MeosMemory.free on it. + public static final UDF2 tfloatValueN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer dPtr = functions.tfloat_value_n(ptr, n); + if (dPtr == null) return null; + return dPtr.getDouble(0); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // ttext value accessors + // ------------------------------------------------------------------ + + // ttextMinValue(trip STRING) → STRING + // MEOS: ttext_min_value(const Temporal *) → text * + public static final UDF1 ttextMinValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer txtPtr = functions.ttext_min_value(ptr); + if (txtPtr == null) return null; + try { + return functions.text_out(txtPtr); + } finally { + MeosMemory.free(txtPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ttextMaxValue(trip STRING) → STRING + // MEOS: ttext_max_value(const Temporal *) → text * + public static final UDF1 ttextMaxValue = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer txtPtr = functions.ttext_max_value(ptr); + if (txtPtr == null) return null; + try { + return functions.text_out(txtPtr); + } finally { + MeosMemory.free(txtPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ttextValueN(trip STRING, n INT) → STRING (n-th value, 1-based) + // MEOS: ttext_value_n(const Temporal *, int) → text * + public static final UDF2 ttextValueN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer txtPtr = functions.ttext_value_n(ptr, n); + if (txtPtr == null) return null; + try { + return functions.text_out(txtPtr); + } finally { + MeosMemory.free(txtPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tpoint accessors + // ------------------------------------------------------------------ + + // tpointSrid(trip STRING) → INT + // MEOS: tspatial_srid(const Temporal *) → int + public static final UDF1 tpointSrid = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.tspatial_srid(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + // tpointValueN(trip STRING, n INT) → STRING (WKT of n-th point, 1-based) + // MEOS: tgeo_value_n(const Temporal *, int, GSERIALIZED **) → bool + public static final UDF2 tpointValueN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer gsPtr = functions.tgeo_value_n(ptr, n); + if (gsPtr == null) return null; + try { + return functions.geo_as_text(gsPtr, 6); + } finally { + MeosMemory.free(gsPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tpointConvexHull(trip STRING) → STRING (WKT of convex hull geometry) + // MEOS: tgeo_convex_hull(const Temporal *) → GSERIALIZED * + public static final UDF1 tpointConvexHull = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer gsPtr = functions.tgeo_convex_hull(ptr); + if (gsPtr == null) return null; + try { + return functions.geo_as_text(gsPtr, 6); + } finally { + MeosMemory.free(gsPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // tint value accessor + // ------------------------------------------------------------------ + + // tintValueN(trip STRING, n INT) → INT (n-th distinct value, 1-based) + // MEOS: tint_value_n(const Temporal *, int n) → int * (JNR-allocated; do NOT MeosMemory.free) + public static final UDF2 tintValueN = + (trip, n) -> { + if (trip == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer valPtr = functions.tint_value_n(ptr, n); + if (valPtr == null) return null; + return valPtr.getInt(0); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // value_at_timestamptz: retrieve value at a given instant + // + // MEOS: tbool_value_at_timestamptz / tint_value_at_timestamptz / + // tfloat_value_at_timestamptz (output-pointer pattern) + // ------------------------------------------------------------------ + + // tboolValueAtTimestamptz(tval STRING, ts TIMESTAMP) → BOOLEAN + public static final UDF2 tboolValueAtTimestamptz = + (tval, ts) -> { + if (tval == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tval); + if (ptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - PG_UNIX_EPOCH_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer outVal = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(1); + boolean found = functions.tbool_value_at_timestamptz(ptr, odt, false, outVal); + if (!found) return null; + return outVal.getByte(0) != 0; + } finally { + MeosMemory.free(ptr); + } + }; + + // tintValueAtTimestamptz(tval STRING, ts TIMESTAMP) → INT + public static final UDF2 tintValueAtTimestamptz = + (tval, ts) -> { + if (tval == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tval); + if (ptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - PG_UNIX_EPOCH_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer outVal = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + boolean found = functions.tint_value_at_timestamptz(ptr, odt, false, outVal); + if (!found) return null; + return outVal.getInt(0); + } finally { + MeosMemory.free(ptr); + } + }; + + // tfloatValueAtTimestamptz(tval STRING, ts TIMESTAMP) → DOUBLE + public static final UDF2 tfloatValueAtTimestamptz = + (tval, ts) -> { + if (tval == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tval); + if (ptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - PG_UNIX_EPOCH_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer outVal = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + boolean found = functions.tfloat_value_at_timestamptz(ptr, odt, false, outVal); + if (!found) return null; + return outVal.getDouble(0); + } finally { + MeosMemory.free(ptr); + } + }; + + // ttextValueAtTimestamptz(tval STRING, ts TIMESTAMP) → STRING + // MEOS: ttext_value_at_timestamptz(temp, t, strict, text **value) → bool + // outBuf holds a text* (MEOS-allocated) — use getPointer(0) then free. + public static final UDF2 ttextValueAtTimestamptz = + (tval, ts) -> { + if (tval == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tval); + if (ptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - PG_UNIX_EPOCH_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer outBuf = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + boolean found = functions.ttext_value_at_timestamptz(ptr, odt, false, outBuf); + if (!found) return null; + Pointer textPtr = outBuf.getPointer(0); + if (textPtr == null) return null; + try { + return functions.text_out(textPtr); + } finally { + MeosMemory.free(textPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static void registerAll(SparkSession spark) { + // Subtype + spark.udf().register("temporalSubtype", temporalSubtype, DataTypes.StringType); + // Instant navigation + spark.udf().register("startInstant", startInstant, DataTypes.StringType); + spark.udf().register("endInstant", endInstant, DataTypes.StringType); + spark.udf().register("instantN", instantN, DataTypes.StringType); + // Sequence navigation + spark.udf().register("startSequence", startSequence, DataTypes.StringType); + spark.udf().register("endSequence", endSequence, DataTypes.StringType); + spark.udf().register("sequenceN", sequenceN, DataTypes.StringType); + // Min/max instant + spark.udf().register("minInstant", minInstant, DataTypes.StringType); + spark.udf().register("maxInstant", maxInstant, DataTypes.StringType); + // Timestamp accessors + spark.udf().register("numTimestamps", numTimestamps, DataTypes.IntegerType); + spark.udf().register("timestampN", timestampN, DataTypes.TimestampType); + // Inclusivity flags + spark.udf().register("lowerInc", lowerInc, DataTypes.BooleanType); + spark.udf().register("upperInc", upperInc, DataTypes.BooleanType); + // Duration + spark.udf().register("duration", duration, DataTypes.StringType); + // tbool value accessor + spark.udf().register("tboolValueN", tboolValueN, DataTypes.BooleanType); + // tfloat value accessor + spark.udf().register("tfloatValueN", tfloatValueN, DataTypes.DoubleType); + // ttext value accessors + spark.udf().register("ttextMinValue", ttextMinValue, DataTypes.StringType); + spark.udf().register("ttextMaxValue", ttextMaxValue, DataTypes.StringType); + spark.udf().register("ttextValueN", ttextValueN, DataTypes.StringType); + // tpoint accessors + spark.udf().register("tpointSrid", tpointSrid, DataTypes.IntegerType); + spark.udf().register("tpointValueN", tpointValueN, DataTypes.StringType); + spark.udf().register("tpointConvexHull", tpointConvexHull, DataTypes.StringType); + // value_at_timestamptz + spark.udf().register("tintValueN", tintValueN, DataTypes.IntegerType); + spark.udf().register("tboolValueAtTimestamptz", tboolValueAtTimestamptz, DataTypes.BooleanType); + spark.udf().register("tintValueAtTimestamptz", tintValueAtTimestamptz, DataTypes.IntegerType); + spark.udf().register("tfloatValueAtTimestamptz", tfloatValueAtTimestamptz, DataTypes.DoubleType); + spark.udf().register("ttextValueAtTimestamptz", ttextValueAtTimestamptz, DataTypes.StringType); + // Array-returning accessors + spark.udf().register("temporalTimestamps", temporalTimestamps, + DataTypes.createArrayType(DataTypes.TimestampType)); + spark.udf().register("tboolValues", tboolValues, + DataTypes.createArrayType(DataTypes.BooleanType)); + spark.udf().register("tintValues", tintValues, + DataTypes.createArrayType(DataTypes.IntegerType)); + spark.udf().register("tfloatValues", tfloatValues, + DataTypes.createArrayType(DataTypes.DoubleType)); + spark.udf().register("temporalInstants", temporalInstants, + DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("temporalSequences", temporalSequences, + DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("temporalSegments", temporalSegments, + DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("ttextValues", ttextValues, + DataTypes.createArrayType(DataTypes.StringType)); + } + + // ------------------------------------------------------------------ + // Array-returning accessors + // + // temporalTimestamps: temporal_timestamps(temp, sizeOut) → TimestampTz[] + // tboolValues: tbool_values(temp, sizeOut) → bool[] + // + // MEOS convention: sizeOut is int * (4 bytes); the returned C array is + // palloc'd and must be freed after use. + // ------------------------------------------------------------------ + + private static final long PG_UNIX_OFFSET_MS = 946684800L * 1000L; + + // temporalTimestamps(hex STRING) → ARRAY + // Returns the distinct timestamps at which the temporal has an instant. + public static final UDF1> temporalTimestamps = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = functions.temporal_timestamps(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + long pgMicros = arrPtr.getLong((long) i * 8); + result.add(new Timestamp(pgMicros / 1000L + PG_UNIX_OFFSET_MS)); + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + }; + + // tboolValues(hex STRING) → ARRAY + // Returns the distinct boolean values present in a tbool. + public static final UDF1> tboolValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = functions.tbool_values(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + result.add(arrPtr.getByte(i) != 0); + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + }; + + // tintValues(hex STRING) → ARRAY + // Returns the distinct integer values present in a tint. + public static final UDF1> tintValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = functions.tint_values(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + result.add(arrPtr.getInt((long) i * 4)); + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + }; + + // tfloatValues(hex STRING) → ARRAY + // Returns the distinct float values present in a tfloat. + public static final UDF1> tfloatValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = functions.tfloat_values(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + result.add(arrPtr.getDouble((long) i * 8)); + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // temporal_instants / temporal_sequences / temporal_segments + // + // Each function returns a Temporal** (array of Temporal* view pointers). + // The array itself is palloc'd and must be freed; the elements are views + // into the original temporal and must NOT be freed. + // + // MEOS: temporal_instants(Temporal *, int *count) → TInstant ** + // temporal_sequences(Temporal *, int *count) → TSequence ** + // temporal_segments(Temporal *, int *count) → TSequence ** + // ------------------------------------------------------------------ + + private static List temporalPtrArray(String hex, + java.util.function.BiFunction fn) { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = fn.apply(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + Pointer elem = arrPtr.getPointer((long) i * 8); + if (elem != null) { + String h = functions.temporal_as_hexwkb(elem, (byte) 0); + if (h != null) result.add(h); + } + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + } + + // temporalInstants(hex STRING) → ARRAY + // Returns each instant of the temporal value as a hex-WKB string. + public static final UDF1> temporalInstants = + (hex) -> temporalPtrArray(hex, functions::temporal_instants); + + // temporalSequences(hex STRING) → ARRAY + // Returns each sequence of a TSequenceSet as hex-WKB strings. + public static final UDF1> temporalSequences = + (hex) -> temporalPtrArray(hex, functions::temporal_sequences); + + // temporalSegments(hex STRING) → ARRAY + // Returns each linear segment of the temporal value as hex-WKB strings. + public static final UDF1> temporalSegments = + (hex) -> temporalPtrArray(hex, functions::temporal_segments); + + // ttextValues(hex STRING) → ARRAY + // Returns the distinct text values of a ttext as Strings. + // MEOS: ttext_values(const Temporal *, int *count) → text ** + // Elements are text* pointers; read via text_out; free the outer array. + public static final UDF1> ttextValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(hex); + if (ptr == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + Pointer arrPtr = functions.ttext_values(ptr, sizeOut); + if (arrPtr == null) return null; + int count = sizeOut.getInt(0); + List result = new ArrayList<>(count); + for (int i = 0; i < count; i++) { + Pointer textPtr = arrPtr.getPointer((long) i * 8); + if (textPtr != null) result.add(functions.text_out(textPtr)); + } + MeosMemory.free(arrPtr); + return result; + } finally { + MeosMemory.free(ptr); + } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/PosOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/PosOpsUDFs.java new file mode 100644 index 00000000..0dea0ddd --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/PosOpsUDFs.java @@ -0,0 +1,470 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for temporal and spatial positional operators. + * + * Three families of operators: + * 1. Time-direction (before/after/overbefore/overafter) on any temporal value. + * 2. Value-direction (left/right/overleft/overright) on tnumber (tint/tfloat). + * 3. Spatial-direction (left/right/overleft/overright/below/above/overbelow/ + * overabove/front/back/overfront/overback) on tpoint (tgeompoint/tgeogpoint). + * + * All inputs are hex-WKB strings; tstzspan inputs also use hex-WKB (span_from_hexwkb). + * All outputs are Boolean. + * + * MEOS function authority: meos/include/meos.h (temporal), meos/include/meos_geo.h (tpoint) + */ +public final class PosOpsUDFs { + + private PosOpsUDFs() {} + + private static Pointer tempPtr(String hex) { + return hex == null ? null : functions.temporal_from_hexwkb(hex); + } + + private static Pointer spanPtr(String hex) { + return hex == null ? null : functions.span_from_hexwkb(hex); + } + + // ------------------------------------------------------------------ + // Time-direction: temporal ↔ temporal + // MEOS: before/after/overbefore/overafter_temporal_temporal → boolean + // ------------------------------------------------------------------ + + public static final UDF2 temporalBefore = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.before_temporal_temporal(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 temporalAfter = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.after_temporal_temporal(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 temporalOverbefore = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overbefore_temporal_temporal(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 temporalOverafter = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overafter_temporal_temporal(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // Time-direction: temporal ↔ tstzspan (hex-WKB span as second arg) + // MEOS: before/after/overbefore/overafter_temporal_tstzspan → boolean + // ------------------------------------------------------------------ + + public static final UDF2 temporalBeforeSpan = + (tHex, spanHex) -> { + if (tHex == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer p = tempPtr(tHex); + if (p == null) return null; + try { + Pointer sp = spanPtr(spanHex); + if (sp == null) return null; + try { + return functions.before_temporal_tstzspan(p, sp); + } finally { MeosMemory.free(sp); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 temporalAfterSpan = + (tHex, spanHex) -> { + if (tHex == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer p = tempPtr(tHex); + if (p == null) return null; + try { + Pointer sp = spanPtr(spanHex); + if (sp == null) return null; + try { + return functions.after_temporal_tstzspan(p, sp); + } finally { MeosMemory.free(sp); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 temporalOverbeforeSpan = + (tHex, spanHex) -> { + if (tHex == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer p = tempPtr(tHex); + if (p == null) return null; + try { + Pointer sp = spanPtr(spanHex); + if (sp == null) return null; + try { + return functions.overbefore_temporal_tstzspan(p, sp); + } finally { MeosMemory.free(sp); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 temporalOverafterSpan = + (tHex, spanHex) -> { + if (tHex == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer p = tempPtr(tHex); + if (p == null) return null; + try { + Pointer sp = spanPtr(spanHex); + if (sp == null) return null; + try { + return functions.overafter_temporal_tstzspan(p, sp); + } finally { MeosMemory.free(sp); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Value-direction: tnumber ↔ tnumber + // MEOS: left/right/overleft/overright_tnumber_tnumber → boolean + // ------------------------------------------------------------------ + + public static final UDF2 tnumberLeft = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.left_tnumber_tnumber(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tnumberRight = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.right_tnumber_tnumber(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tnumberOverleft = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overleft_tnumber_tnumber(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tnumberOverright = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overright_tnumber_tnumber(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // Spatial-direction x-axis: tpoint ↔ tpoint + // MEOS: left/right/overleft/overright_tspatial_tspatial → boolean + // ------------------------------------------------------------------ + + public static final UDF2 tpointLeft = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.left_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointRight = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.right_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverleft = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overleft_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverright = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overright_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // Spatial-direction y-axis: tpoint ↔ tpoint + // MEOS: below/above/overbelow/overabove_tspatial_tspatial → boolean + // ------------------------------------------------------------------ + + public static final UDF2 tpointBelow = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.below_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointAbove = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.above_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverbelow = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overbelow_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverabove = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overabove_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // Spatial-direction z-axis (3D): tpoint ↔ tpoint + // MEOS: front/back/overfront/overback_tspatial_tspatial → boolean + // ------------------------------------------------------------------ + + public static final UDF2 tpointFront = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.front_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointBack = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.back_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverfront = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overfront_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + public static final UDF2 tpointOverback = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1); + if (p1 == null) return null; + try { + Pointer p2 = tempPtr(s2); + if (p2 == null) return null; + try { + return functions.overback_tspatial_tspatial(p1, p2); + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // The portable bare names before/after/overbefore/overafter (time) + // and left/right/overleft/overright/below/above/overbelow/overabove/ + // front/back/overfront/overback (space) supersede the type-qualified + // temporal*/tnumber*/tpoint* spellings 1:1 and are registered by + // org.mobilitydb.spark.portable.PortableOperatorAliasUDFs, which + // reuses the very backing fields below. The distinct + // temporal ↔ tstzspan argument-class surface has no single bare + // spelling and is retained here. + spark.udf().register("temporalBeforeSpan", temporalBeforeSpan, DataTypes.BooleanType); + spark.udf().register("temporalAfterSpan", temporalAfterSpan, DataTypes.BooleanType); + spark.udf().register("temporalOverbeforeSpan",temporalOverbeforeSpan,DataTypes.BooleanType); + spark.udf().register("temporalOverafterSpan", temporalOverafterSpan, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/PredicateUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/PredicateUDFs.java new file mode 100644 index 00000000..786448f3 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/PredicateUDFs.java @@ -0,0 +1,795 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for temporal comparisons and ever/always predicate lifting. + * + * Temporal order comparison (temporalEq, temporalLt, …) compares two temporal + * values lexicographically by their sequence of instants. + * + * Ever/always predicates follow the MEOS convention of returning int: + * 1 = predicate holds for every/some instant, 0 = it does not, -1 = error. + * All UDFs here convert that int to Boolean (null for error). + * + * MEOS function authority: meos/include/meos.h + */ +public final class PredicateUDFs { + + private PredicateUDFs() {} + + private static Pointer tempPtr(String hex) { + return hex == null ? null : functions.temporal_from_hexwkb(hex); + } + + /** Convert MEOS ever/always int result to Boolean; null on error (-1). */ + private static Boolean intToBool(int v) { + if (v < 0) return null; + return v != 0; + } + + // ------------------------------------------------------------------ + // Temporal order comparisons (hex, hex) → Boolean + // + // These compare two temporal values as ordered objects (lexicographic + // by instant sequence), not instant-by-instant. + // + // MEOS: temporal_eq / temporal_ne / temporal_lt / temporal_le + // temporal_gt / temporal_ge + // ------------------------------------------------------------------ + + // temporalEq(t1, t2) → true if t1 and t2 have identical instant sequences + public static final UDF2 temporalEq = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_eq(p1, p2); + }; + + // temporalNe(t1, t2) → true if t1 and t2 differ + public static final UDF2 temporalNe = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_ne(p1, p2); + }; + + // temporalLt(t1, t2) → true if t1 < t2 (lexicographic) + public static final UDF2 temporalLt = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_lt(p1, p2); + }; + + // temporalLe(t1, t2) → true if t1 ≤ t2 + public static final UDF2 temporalLe = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_le(p1, p2); + }; + + // temporalGt(t1, t2) → true if t1 > t2 + public static final UDF2 temporalGt = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_gt(p1, p2); + }; + + // temporalGe(t1, t2) → true if t1 ≥ t2 + public static final UDF2 temporalGe = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.temporal_ge(p1, p2); + }; + + // ------------------------------------------------------------------ + // ever_eq predicates: did the temporal value ever equal the scalar? + // + // MEOS: ever_eq_tint_int / ever_eq_tfloat_float + // ever_eq_temporal_temporal + // ------------------------------------------------------------------ + + // everEqTintInt(tint_hex, 5) → true if tint ever equals 5 + // MEOS: ever_eq_tint_int(Temporal *, int) → int + public static final UDF2 everEqTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_eq_tint_int(ptr, v)); + }; + + // everEqTfloatFloat(tfloat_hex, 1.5) → true if tfloat ever equals 1.5 + // MEOS: ever_eq_tfloat_float(Temporal *, double) → int + public static final UDF2 everEqTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_eq_tfloat_float(ptr, v)); + }; + + // everEqTemporal(t1, t2) → true if t1 and t2 ever have the same value + // MEOS: ever_eq_temporal_temporal(Temporal *, Temporal *) → int + public static final UDF2 everEqTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_eq_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // ever_ne predicates: did the temporal value ever differ from the scalar? + // + // MEOS: ever_ne_tint_int / ever_ne_tfloat_float / ever_ne_temporal_temporal + // ------------------------------------------------------------------ + + public static final UDF2 everNeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_ne_tint_int(ptr, v)); + }; + + public static final UDF2 everNeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_ne_tfloat_float(ptr, v)); + }; + + public static final UDF2 everNeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_ne_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // ever_lt predicates + // + // MEOS: ever_lt_tint_int / ever_lt_tfloat_float / ever_lt_temporal_temporal + // ------------------------------------------------------------------ + + // everLtTintInt(tint_hex, 10) → true if tint ever < 10 + public static final UDF2 everLtTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_lt_tint_int(ptr, v)); + }; + + // everLtTfloatFloat(tfloat_hex, 2.0) → true if tfloat ever < 2.0 + public static final UDF2 everLtTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_lt_tfloat_float(ptr, v)); + }; + + // everLtTemporal(t1, t2) → true if t1 ever < t2 at any shared instant + public static final UDF2 everLtTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_lt_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // ever_le predicates + // ------------------------------------------------------------------ + + public static final UDF2 everLeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_le_tint_int(ptr, v)); + }; + + public static final UDF2 everLeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_le_tfloat_float(ptr, v)); + }; + + public static final UDF2 everLeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_le_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // ever_gt / ever_ge predicates + // ------------------------------------------------------------------ + + public static final UDF2 everGtTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_gt_tint_int(ptr, v)); + }; + + public static final UDF2 everGtTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_gt_tfloat_float(ptr, v)); + }; + + public static final UDF2 everGtTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_gt_temporal_temporal(p1, p2)); + }; + + public static final UDF2 everGeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_ge_tint_int(ptr, v)); + }; + + public static final UDF2 everGeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.ever_ge_tfloat_float(ptr, v)); + }; + + public static final UDF2 everGeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.ever_ge_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // always_eq predicates + // + // MEOS: always_eq_tint_int / always_eq_tfloat_float + // always_eq_temporal_temporal + // ------------------------------------------------------------------ + + public static final UDF2 alwaysEqTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_eq_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysEqTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_eq_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysEqTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_eq_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // always_ne predicates + // + // MEOS: always_ne_tint_int / always_ne_tfloat_float / always_ne_temporal_temporal + // ------------------------------------------------------------------ + + public static final UDF2 alwaysNeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_ne_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysNeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_ne_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysNeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_ne_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // always_lt predicates + // ------------------------------------------------------------------ + + public static final UDF2 alwaysLtTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_lt_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysLtTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_lt_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysLtTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_lt_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // always_le predicates + // ------------------------------------------------------------------ + + public static final UDF2 alwaysLeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_le_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysLeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_le_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysLeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_le_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // always_gt / always_ge predicates + // ------------------------------------------------------------------ + + public static final UDF2 alwaysGtTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_gt_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysGtTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_gt_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysGtTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_gt_temporal_temporal(p1, p2)); + }; + + public static final UDF2 alwaysGeTintInt = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_ge_tint_int(ptr, v)); + }; + + public static final UDF2 alwaysGeTfloatFloat = + (s, v) -> { + MeosThread.ensureReady(); + Pointer ptr = tempPtr(s); + if (ptr == null || v == null) return null; + return intToBool(functions.always_ge_tfloat_float(ptr, v)); + }; + + public static final UDF2 alwaysGeTemporal = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = tempPtr(s1), p2 = tempPtr(s2); + if (p1 == null || p2 == null) return null; + return intToBool(functions.always_ge_temporal_temporal(p1, p2)); + }; + + // ------------------------------------------------------------------ + // Scalar-first reversed forms: (int OP tint), (float OP tfloat) + // MEOS: always_eq_int_tint(int, Temporal *) → int, etc. + // ------------------------------------------------------------------ + + public static final UDF2 alwaysEqIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_eq_int_tint(v, p)); }; + public static final UDF2 alwaysNeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ne_int_tint(v, p)); }; + public static final UDF2 alwaysLtIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_lt_int_tint(v, p)); }; + public static final UDF2 alwaysLeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_le_int_tint(v, p)); }; + public static final UDF2 alwaysGtIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_gt_int_tint(v, p)); }; + public static final UDF2 alwaysGeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ge_int_tint(v, p)); }; + + public static final UDF2 alwaysEqFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_eq_float_tfloat(v, p)); }; + public static final UDF2 alwaysNeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ne_float_tfloat(v, p)); }; + public static final UDF2 alwaysLtFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_lt_float_tfloat(v, p)); }; + public static final UDF2 alwaysLeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_le_float_tfloat(v, p)); }; + public static final UDF2 alwaysGtFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_gt_float_tfloat(v, p)); }; + public static final UDF2 alwaysGeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ge_float_tfloat(v, p)); }; + + public static final UDF2 everEqIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_eq_int_tint(v, p)); }; + public static final UDF2 everNeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ne_int_tint(v, p)); }; + public static final UDF2 everLtIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_lt_int_tint(v, p)); }; + public static final UDF2 everLeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_le_int_tint(v, p)); }; + public static final UDF2 everGtIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_gt_int_tint(v, p)); }; + public static final UDF2 everGeIntTint = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ge_int_tint(v, p)); }; + + public static final UDF2 everEqFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_eq_float_tfloat(v, p)); }; + public static final UDF2 everNeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ne_float_tfloat(v, p)); }; + public static final UDF2 everLtFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_lt_float_tfloat(v, p)); }; + public static final UDF2 everLeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_le_float_tfloat(v, p)); }; + public static final UDF2 everGtFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_gt_float_tfloat(v, p)); }; + public static final UDF2 everGeFloatTfloat = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ge_float_tfloat(v, p)); }; + + // ------------------------------------------------------------------ + // tbool × bool predicates (only eq and ne meaningful for booleans) + // MEOS: ever_eq_tbool_bool(Temporal *, bool) → int, etc. + // ------------------------------------------------------------------ + + public static final UDF2 alwaysEqTboolBool = + (s, v) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_eq_tbool_bool(p, v)); }; + public static final UDF2 alwaysNeTboolBool = + (s, v) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ne_tbool_bool(p, v)); }; + public static final UDF2 alwaysEqBoolTbool = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_eq_bool_tbool(v, p)); }; + public static final UDF2 alwaysNeBoolTbool = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.always_ne_bool_tbool(v, p)); }; + + public static final UDF2 everEqTboolBool = + (s, v) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_eq_tbool_bool(p, v)); }; + public static final UDF2 everNeTboolBool = + (s, v) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ne_tbool_bool(p, v)); }; + public static final UDF2 everEqBoolTbool = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_eq_bool_tbool(v, p)); }; + public static final UDF2 everNeBoolTbool = + (v, s) -> { MeosThread.ensureReady(); Pointer p = tempPtr(s); if (p == null || v == null) return null; return intToBool(functions.ever_ne_bool_tbool(v, p)); }; + + // ------------------------------------------------------------------ + // ttext × text predicates + // text* is obtained via ttext_in + ttext_value_n (text_in not exposed). + // MEOS: always_eq_text_ttext(text *, Temporal *) → int, etc. + // ------------------------------------------------------------------ + + private static Pointer[] makeTextPtr(String val) { + Pointer dummy = functions.ttext_in(val + "@2000-01-01 00:00:00+00"); + if (dummy == null) return null; + Pointer textPtr = functions.ttext_value_n(dummy, 1); + if (textPtr == null) { MeosMemory.free(dummy); return null; } + return new Pointer[]{textPtr, dummy}; + } + + private static Boolean textTtextPred(String textVal, String ttextHex, + BiFunction fn) { + if (textVal == null || ttextHex == null) return null; + MeosThread.ensureReady(); + Pointer[] tp = makeTextPtr(textVal); + if (tp == null) return null; + Pointer tptr = functions.temporal_from_hexwkb(ttextHex); + if (tptr == null) { MeosMemory.free(tp[0]); MeosMemory.free(tp[1]); return null; } + try { + return intToBool(fn.apply(tp[0], tptr)); + } finally { + MeosMemory.free(tptr); + MeosMemory.free(tp[0]); + MeosMemory.free(tp[1]); + } + } + + private static Boolean ttextTextPred(String ttextHex, String textVal, + BiFunction fn) { + if (ttextHex == null || textVal == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(ttextHex); + if (tptr == null) return null; + Pointer[] tp = makeTextPtr(textVal); + if (tp == null) { MeosMemory.free(tptr); return null; } + try { + return intToBool(fn.apply(tptr, tp[0])); + } finally { + MeosMemory.free(tptr); + MeosMemory.free(tp[0]); + MeosMemory.free(tp[1]); + } + } + + // always: text OP ttext + public static final UDF2 alwaysEqTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_eq_text_ttext); + public static final UDF2 alwaysNeTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_ne_text_ttext); + public static final UDF2 alwaysLtTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_lt_text_ttext); + public static final UDF2 alwaysLeTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_le_text_ttext); + public static final UDF2 alwaysGtTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_gt_text_ttext); + public static final UDF2 alwaysGeTextTtext = + (t, s) -> textTtextPred(t, s, functions::always_ge_text_ttext); + + // always: ttext OP text + public static final UDF2 alwaysEqTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_eq_ttext_text); + public static final UDF2 alwaysNeTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_ne_ttext_text); + public static final UDF2 alwaysLtTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_lt_ttext_text); + public static final UDF2 alwaysLeTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_le_ttext_text); + public static final UDF2 alwaysGtTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_gt_ttext_text); + public static final UDF2 alwaysGeTtextText = + (s, t) -> ttextTextPred(s, t, functions::always_ge_ttext_text); + + // ever: text OP ttext + public static final UDF2 everEqTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_eq_text_ttext); + public static final UDF2 everNeTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_ne_text_ttext); + public static final UDF2 everLtTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_lt_text_ttext); + public static final UDF2 everLeTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_le_text_ttext); + public static final UDF2 everGtTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_gt_text_ttext); + public static final UDF2 everGeTextTtext = + (t, s) -> textTtextPred(t, s, functions::ever_ge_text_ttext); + + // ever: ttext OP text + public static final UDF2 everEqTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_eq_ttext_text); + public static final UDF2 everNeTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_ne_ttext_text); + public static final UDF2 everLtTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_lt_ttext_text); + public static final UDF2 everLeTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_le_ttext_text); + public static final UDF2 everGtTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_gt_ttext_text); + public static final UDF2 everGeTtextText = + (s, t) -> ttextTextPred(s, t, functions::ever_ge_ttext_text); + + // tpointIsSimple(tpoint_hex) → Boolean + // Returns true if the trajectory has no self-intersections. + // MEOS: tpoint_is_simple(const Temporal *) → bool + public static final UDF1 tpointIsSimple = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + return functions.tpoint_is_simple(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static void registerAll(SparkSession spark) { + // Temporal order comparisons + spark.udf().register("temporalEq", temporalEq, DataTypes.BooleanType); + spark.udf().register("temporalNe", temporalNe, DataTypes.BooleanType); + spark.udf().register("temporalLt", temporalLt, DataTypes.BooleanType); + spark.udf().register("temporalLe", temporalLe, DataTypes.BooleanType); + spark.udf().register("temporalGt", temporalGt, DataTypes.BooleanType); + spark.udf().register("temporalGe", temporalGe, DataTypes.BooleanType); + // ever_eq + spark.udf().register("everEqTintInt", everEqTintInt, DataTypes.BooleanType); + spark.udf().register("everEqTfloatFloat", everEqTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everEqTemporal", everEqTemporal, DataTypes.BooleanType); + // ever_lt + spark.udf().register("everLtTintInt", everLtTintInt, DataTypes.BooleanType); + spark.udf().register("everLtTfloatFloat", everLtTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everLtTemporal", everLtTemporal, DataTypes.BooleanType); + // ever_le + spark.udf().register("everLeTintInt", everLeTintInt, DataTypes.BooleanType); + spark.udf().register("everLeTfloatFloat", everLeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everLeTemporal", everLeTemporal, DataTypes.BooleanType); + // ever_gt + spark.udf().register("everGtTintInt", everGtTintInt, DataTypes.BooleanType); + spark.udf().register("everGtTfloatFloat", everGtTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everGtTemporal", everGtTemporal, DataTypes.BooleanType); + // ever_ge + spark.udf().register("everGeTintInt", everGeTintInt, DataTypes.BooleanType); + spark.udf().register("everGeTfloatFloat", everGeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everGeTemporal", everGeTemporal, DataTypes.BooleanType); + // ever_ne + spark.udf().register("everNeTintInt", everNeTintInt, DataTypes.BooleanType); + spark.udf().register("everNeTfloatFloat", everNeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("everNeTemporal", everNeTemporal, DataTypes.BooleanType); + // always_eq + spark.udf().register("alwaysEqTintInt", alwaysEqTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysEqTfloatFloat", alwaysEqTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysEqTemporal", alwaysEqTemporal, DataTypes.BooleanType); + // always_lt + spark.udf().register("alwaysLtTintInt", alwaysLtTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysLtTfloatFloat", alwaysLtTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysLtTemporal", alwaysLtTemporal, DataTypes.BooleanType); + // always_le + spark.udf().register("alwaysLeTintInt", alwaysLeTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysLeTfloatFloat", alwaysLeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysLeTemporal", alwaysLeTemporal, DataTypes.BooleanType); + // always_gt + spark.udf().register("alwaysGtTintInt", alwaysGtTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysGtTfloatFloat", alwaysGtTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysGtTemporal", alwaysGtTemporal, DataTypes.BooleanType); + // always_ge + spark.udf().register("alwaysGeTintInt", alwaysGeTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysGeTfloatFloat", alwaysGeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysGeTemporal", alwaysGeTemporal, DataTypes.BooleanType); + // always_ne + spark.udf().register("alwaysNeTintInt", alwaysNeTintInt, DataTypes.BooleanType); + spark.udf().register("alwaysNeTfloatFloat", alwaysNeTfloatFloat, DataTypes.BooleanType); + spark.udf().register("alwaysNeTemporal", alwaysNeTemporal, DataTypes.BooleanType); + // scalar-first reversed forms + spark.udf().register("alwaysEqIntTint", alwaysEqIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysNeIntTint", alwaysNeIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysLtIntTint", alwaysLtIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysLeIntTint", alwaysLeIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysGtIntTint", alwaysGtIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysGeIntTint", alwaysGeIntTint, DataTypes.BooleanType); + spark.udf().register("alwaysEqFloatTfloat", alwaysEqFloatTfloat, DataTypes.BooleanType); + spark.udf().register("alwaysNeFloatTfloat", alwaysNeFloatTfloat, DataTypes.BooleanType); + spark.udf().register("alwaysLtFloatTfloat", alwaysLtFloatTfloat, DataTypes.BooleanType); + spark.udf().register("alwaysLeFloatTfloat", alwaysLeFloatTfloat, DataTypes.BooleanType); + spark.udf().register("alwaysGtFloatTfloat", alwaysGtFloatTfloat, DataTypes.BooleanType); + spark.udf().register("alwaysGeFloatTfloat", alwaysGeFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everEqIntTint", everEqIntTint, DataTypes.BooleanType); + spark.udf().register("everNeIntTint", everNeIntTint, DataTypes.BooleanType); + spark.udf().register("everLtIntTint", everLtIntTint, DataTypes.BooleanType); + spark.udf().register("everLeIntTint", everLeIntTint, DataTypes.BooleanType); + spark.udf().register("everGtIntTint", everGtIntTint, DataTypes.BooleanType); + spark.udf().register("everGeIntTint", everGeIntTint, DataTypes.BooleanType); + spark.udf().register("everEqFloatTfloat", everEqFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everNeFloatTfloat", everNeFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everLtFloatTfloat", everLtFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everLeFloatTfloat", everLeFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everGtFloatTfloat", everGtFloatTfloat, DataTypes.BooleanType); + spark.udf().register("everGeFloatTfloat", everGeFloatTfloat, DataTypes.BooleanType); + // tbool × bool predicates + spark.udf().register("alwaysEqTboolBool", alwaysEqTboolBool, DataTypes.BooleanType); + spark.udf().register("alwaysNeTboolBool", alwaysNeTboolBool, DataTypes.BooleanType); + spark.udf().register("alwaysEqBoolTbool", alwaysEqBoolTbool, DataTypes.BooleanType); + spark.udf().register("alwaysNeBoolTbool", alwaysNeBoolTbool, DataTypes.BooleanType); + spark.udf().register("everEqTboolBool", everEqTboolBool, DataTypes.BooleanType); + spark.udf().register("everNeTboolBool", everNeTboolBool, DataTypes.BooleanType); + spark.udf().register("everEqBoolTbool", everEqBoolTbool, DataTypes.BooleanType); + spark.udf().register("everNeBoolTbool", everNeBoolTbool, DataTypes.BooleanType); + // text × ttext predicates + spark.udf().register("alwaysEqTextTtext", alwaysEqTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysNeTextTtext", alwaysNeTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysLtTextTtext", alwaysLtTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysLeTextTtext", alwaysLeTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysGtTextTtext", alwaysGtTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysGeTextTtext", alwaysGeTextTtext, DataTypes.BooleanType); + spark.udf().register("alwaysEqTtextText", alwaysEqTtextText, DataTypes.BooleanType); + spark.udf().register("alwaysNeTtextText", alwaysNeTtextText, DataTypes.BooleanType); + spark.udf().register("alwaysLtTtextText", alwaysLtTtextText, DataTypes.BooleanType); + spark.udf().register("alwaysLeTtextText", alwaysLeTtextText, DataTypes.BooleanType); + spark.udf().register("alwaysGtTtextText", alwaysGtTtextText, DataTypes.BooleanType); + spark.udf().register("alwaysGeTtextText", alwaysGeTtextText, DataTypes.BooleanType); + spark.udf().register("everEqTextTtext", everEqTextTtext, DataTypes.BooleanType); + spark.udf().register("everNeTextTtext", everNeTextTtext, DataTypes.BooleanType); + spark.udf().register("everLtTextTtext", everLtTextTtext, DataTypes.BooleanType); + spark.udf().register("everLeTextTtext", everLeTextTtext, DataTypes.BooleanType); + spark.udf().register("everGtTextTtext", everGtTextTtext, DataTypes.BooleanType); + spark.udf().register("everGeTextTtext", everGeTextTtext, DataTypes.BooleanType); + spark.udf().register("everEqTtextText", everEqTtextText, DataTypes.BooleanType); + spark.udf().register("everNeTtextText", everNeTtextText, DataTypes.BooleanType); + spark.udf().register("everLtTtextText", everLtTtextText, DataTypes.BooleanType); + spark.udf().register("everLeTtextText", everLeTtextText, DataTypes.BooleanType); + spark.udf().register("everGtTtextText", everGtTtextText, DataTypes.BooleanType); + spark.udf().register("everGeTtextText", everGeTtextText, DataTypes.BooleanType); + // tpoint geometry predicate + spark.udf().register("tpointIsSimple", tpointIsSimple, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/RestrictionUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/RestrictionUDFs.java new file mode 100644 index 00000000..4efe357d --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/RestrictionUDFs.java @@ -0,0 +1,1078 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.sql.Timestamp; +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for restricting temporal values by value or timestamp set. + * + * All temporal values are encoded as hex-WKB Strings. Geometry inputs are + * WKT Strings. Timestamp-set/span/spanset inputs are hex-WKB Strings. + * + * Memory management: every native Pointer allocated by MEOS is freed via + * MeosMemory.free() in a finally block to prevent native heap leakage. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +public final class RestrictionUDFs { + + private RestrictionUDFs() {} + + // ------------------------------------------------------------------ + // Timestamp-set restriction + // ------------------------------------------------------------------ + + // temporalAtTstzspan(s STRING, spanHex STRING) → STRING + // MEOS: temporal_at_tstzspan(const Temporal *, const Span *) → Temporal * + public static final UDF2 temporalAtTstzspan = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanPtr = functions.span_from_hexwkb(spanHex); + if (spanPtr == null) return null; + try { + Pointer result = functions.temporal_at_tstzspan(tptr, spanPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalAtTstzspanset(s STRING, spansetHex STRING) → STRING + // MEOS: temporal_at_tstzspanset(const Temporal *, const SpanSet *) → Temporal * + public static final UDF2 temporalAtTstzspanset = + (s, spansetHex) -> { + if (s == null || spansetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer ssPtr = functions.spanset_from_hexwkb(spansetHex); + if (ssPtr == null) return null; + try { + Pointer result = functions.temporal_at_tstzspanset(tptr, ssPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ssPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalAtTstzset(s STRING, tstzsetHex STRING) → STRING + // MEOS: temporal_at_tstzset(const Temporal *, const Set *) → Temporal * + public static final UDF2 temporalAtTstzset = + (s, tstzsetHex) -> { + if (s == null || tstzsetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer setptr = functions.set_from_hexwkb(tstzsetHex); + if (setptr == null) return null; + try { + Pointer result = functions.temporal_at_tstzset(tptr, setptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(setptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalMinusTstzset(s STRING, tstzsetHex STRING) → STRING + // MEOS: temporal_minus_tstzset(const Temporal *, const Set *) → Temporal * + public static final UDF2 temporalMinusTstzset = + (s, tstzsetHex) -> { + if (s == null || tstzsetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer setptr = functions.set_from_hexwkb(tstzsetHex); + if (setptr == null) return null; + try { + Pointer result = functions.temporal_minus_tstzset(tptr, setptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(setptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalMinusTstzspan(s STRING, spanHex STRING) → STRING + // MEOS: temporal_minus_tstzspan(const Temporal *, const Span *) → Temporal * + public static final UDF2 temporalMinusTstzspan = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanptr = functions.span_from_hexwkb(spanHex); + if (spanptr == null) return null; + try { + Pointer result = functions.temporal_minus_tstzspan(tptr, spanptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalMinusTstzspanset(s STRING, ssHex STRING) → STRING + // MEOS: temporal_minus_tstzspanset(const Temporal *, const SpanSet *) → Temporal * + public static final UDF2 temporalMinusTstzspanset = + (s, ssHex) -> { + if (s == null || ssHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer ssptr = functions.spanset_from_hexwkb(ssHex); + if (ssptr == null) return null; + try { + Pointer result = functions.temporal_minus_tstzspanset(tptr, ssptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ssptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Delete operations (gap-free removal) + // ------------------------------------------------------------------ + + // temporalDeleteTstzspan(s STRING, spanHex STRING) → STRING + // MEOS: temporal_delete_tstzspan(const Temporal *, const Span *, bool connect) → Temporal * + public static final UDF2 temporalDeleteTstzspan = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanptr = functions.span_from_hexwkb(spanHex); + if (spanptr == null) return null; + try { + Pointer result = functions.temporal_delete_tstzspan(tptr, spanptr, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalDeleteTstzspanset(s STRING, ssHex STRING) → STRING + // MEOS: temporal_delete_tstzspanset(const Temporal *, const SpanSet *, bool connect) → Temporal * + public static final UDF2 temporalDeleteTstzspanset = + (s, ssHex) -> { + if (s == null || ssHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer ssptr = functions.spanset_from_hexwkb(ssHex); + if (ssptr == null) return null; + try { + Pointer result = functions.temporal_delete_tstzspanset(tptr, ssptr, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ssptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalDeleteTstzset(s STRING, setHex STRING) → STRING + // MEOS: temporal_delete_tstzset(const Temporal *, const Set *, bool connect) → Temporal * + public static final UDF2 temporalDeleteTstzset = + (s, setHex) -> { + if (s == null || setHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer sptr = functions.set_from_hexwkb(setHex); + if (sptr == null) return null; + try { + Pointer result = functions.temporal_delete_tstzset(tptr, sptr, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(sptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalDeleteTimestamptz(s STRING, ts TIMESTAMP) → STRING + // MEOS: temporal_delete_timestamptz(const Temporal *, TimestampTz, bool connect) → Temporal * + public static final UDF2 temporalDeleteTimestamptz = + (s, ts) -> { + if (s == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - 946684800L * 1000L) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer result = functions.temporal_delete_timestamptz(tptr, odt, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Timestamp restriction (AT / MINUS for a single timestamptz) + // ------------------------------------------------------------------ + + // temporalAtTimestamptz(s STRING, ts TIMESTAMP) → STRING + // MEOS: temporal_at_timestamptz(const Temporal *, TimestampTz) → Temporal * + public static final UDF2 temporalAtTimestamptz = + (s, ts) -> { + if (s == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - 946684800L * 1000L) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer result = functions.temporal_at_timestamptz(tptr, odt); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalMinusTimestamptz(s STRING, ts TIMESTAMP) → STRING + // MEOS: temporal_minus_timestamptz(const Temporal *, TimestampTz) → Temporal * + public static final UDF2 temporalMinusTimestamptz = + (s, ts) -> { + if (s == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + long pgEpochMicros = (ts.getTime() - 946684800L * 1000L) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant( + Instant.ofEpochSecond(pgEpochMicros, 0), ZoneOffset.UTC); + Pointer result = functions.temporal_minus_timestamptz(tptr, odt); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Value restriction: tfloat + // ------------------------------------------------------------------ + + // tfloatAtValue(s STRING, value DOUBLE) → STRING + // MEOS: tfloat_at_value(const Temporal *, double) → Temporal * + public static final UDF2 tfloatAtValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tfloat_at_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tfloatMinusValue(s STRING, value DOUBLE) → STRING + // MEOS: tfloat_minus_value(const Temporal *, double) → Temporal * + public static final UDF2 tfloatMinusValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tfloat_minus_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tintAtValue(s STRING, value INT) → STRING + // MEOS: tint_at_value(const Temporal *, int) → Temporal * + public static final UDF2 tintAtValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tint_at_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tintMinusValue(s STRING, value INT) → STRING + // MEOS: tint_minus_value(const Temporal *, int) → Temporal * + public static final UDF2 tintMinusValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tint_minus_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Value-range restriction: tnumber (floatspan / intspan) + // ------------------------------------------------------------------ + + // tnumberAtSpan(s STRING, spanHex STRING) → STRING + // MEOS: tnumber_at_span(const Temporal *, const Span *) → Temporal * + public static final UDF2 tnumberAtSpan = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanPtr = functions.span_from_hexwkb(spanHex); + if (spanPtr == null) return null; + try { + Pointer result = functions.tnumber_at_span(tptr, spanPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tnumberMinusSpan(s STRING, spanHex STRING) → STRING + // MEOS: tnumber_minus_span(const Temporal *, const Span *) → Temporal * + public static final UDF2 tnumberMinusSpan = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanPtr = functions.span_from_hexwkb(spanHex); + if (spanPtr == null) return null; + try { + Pointer result = functions.tnumber_minus_span(tptr, spanPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tnumberAtSpanset(s STRING, spansetHex STRING) → STRING + // MEOS: tnumber_at_spanset(const Temporal *, const SpanSet *) → Temporal * + public static final UDF2 tnumberAtSpanset = + (s, spansetHex) -> { + if (s == null || spansetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer ssPtr = functions.spanset_from_hexwkb(spansetHex); + if (ssPtr == null) return null; + try { + Pointer result = functions.tnumber_at_spanset(tptr, ssPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ssPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tnumberMinusSpanset(s STRING, spansetHex STRING) → STRING + // MEOS: tnumber_minus_spanset(const Temporal *, const SpanSet *) → Temporal * + public static final UDF2 tnumberMinusSpanset = + (s, spansetHex) -> { + if (s == null || spansetHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer ssPtr = functions.spanset_from_hexwkb(spansetHex); + if (ssPtr == null) return null; + try { + Pointer result = functions.tnumber_minus_spanset(tptr, ssPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ssPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Value restriction: tbool + // ------------------------------------------------------------------ + + // tboolAtValue(s STRING, value BOOLEAN) → STRING + // MEOS: tbool_at_value(const Temporal *, bool) → Temporal * + public static final UDF2 tboolAtValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tbool_at_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tboolMinusValue(s STRING, value BOOLEAN) → STRING + // MEOS: tbool_minus_value(const Temporal *, bool) → Temporal * + public static final UDF2 tboolMinusValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer result = functions.tbool_minus_value(tptr, value); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Value restriction: ttext + // ------------------------------------------------------------------ + + // ttextAtValue(s STRING, value STRING) → STRING + // MEOS: ttext_at_value(const Temporal *, text *) → Temporal * + // The value String is converted to a MEOS text* via cstring2text. + public static final UDF2 ttextAtValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer txtptr = functions.cstring2text(value); + if (txtptr == null) return null; + try { + Pointer result = functions.ttext_at_value(tptr, txtptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(txtptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ttextMinusValue(s STRING, value STRING) → STRING + // MEOS: ttext_minus_value(const Temporal *, text *) → Temporal * + public static final UDF2 ttextMinusValue = + (s, value) -> { + if (s == null || value == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer txtptr = functions.cstring2text(value); + if (txtptr == null) return null; + try { + Pointer result = functions.ttext_minus_value(tptr, txtptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(txtptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Value restriction: tpoint + // ------------------------------------------------------------------ + + // tpointAtValue(s STRING, geomWkt STRING) → STRING + // MEOS: tpoint_at_value(const Temporal *, GSERIALIZED *) → Temporal * + // The geometry WKT is parsed via geo_from_text with SRID 0. + public static final UDF2 tpointAtValue = + (s, geomWkt) -> { + if (s == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) return null; + try { + Pointer result = functions.tpoint_at_value(tptr, gsptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(gsptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tpointMinusValue(s STRING, geomWkt STRING) → STRING + // MEOS: tpoint_minus_value(const Temporal *, GSERIALIZED *) → Temporal * + public static final UDF2 tpointMinusValue = + (s, geomWkt) -> { + if (s == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) return null; + try { + Pointer result = functions.tpoint_minus_value(tptr, gsptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(gsptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // STBox and elevation restriction (tpoint) + // ------------------------------------------------------------------ + + // tgeoAtStbox(s STRING, stboxHex STRING) → STRING + // MEOS: tgeo_at_stbox(const Temporal *, const STBox *, bool border_inc) → Temporal * + public static final UDF2 tgeoAtStbox = + (s, stboxHex) -> { + if (s == null || stboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer boxPtr = functions.stbox_from_hexwkb(stboxHex); + if (boxPtr == null) return null; + try { + Pointer result = functions.tgeo_at_stbox(tptr, boxPtr, true); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(boxPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tgeoMinusStbox(s STRING, stboxHex STRING) → STRING + // MEOS: tgeo_minus_stbox(const Temporal *, const STBox *, bool border_inc) → Temporal * + public static final UDF2 tgeoMinusStbox = + (s, stboxHex) -> { + if (s == null || stboxHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer boxPtr = functions.stbox_from_hexwkb(stboxHex); + if (boxPtr == null) return null; + try { + Pointer result = functions.tgeo_minus_stbox(tptr, boxPtr, true); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(boxPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tpointAtElevation(s STRING, floatspanHex STRING) → STRING + // MEOS: tpoint_at_elevation(const Temporal *, const Span *) → Temporal * + public static final UDF2 tpointAtElevation = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanPtr = functions.span_from_hexwkb(spanHex); + if (spanPtr == null) return null; + try { + Pointer result = functions.tpoint_at_elevation(tptr, spanPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tpointMinusElevation(s STRING, floatspanHex STRING) → STRING + // MEOS: tpoint_minus_elevation(const Temporal *, const Span *) → Temporal * + public static final UDF2 tpointMinusElevation = + (s, spanHex) -> { + if (s == null || spanHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer spanPtr = functions.span_from_hexwkb(spanHex); + if (spanPtr == null) return null; + try { + Pointer result = functions.tpoint_minus_elevation(tptr, spanPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(spanPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Extrema restriction — at maximum / minimum value + // ------------------------------------------------------------------ + + // temporalAtMax(s STRING) → STRING (restricts to instants at the maximum value) + // MEOS: temporal_at_max(const Temporal *) → Temporal * + public static final UDF1 temporalAtMax = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_at_max(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalAtMin(s STRING) → STRING (restricts to instants at the minimum value) + // MEOS: temporal_at_min(const Temporal *) → Temporal * + public static final UDF1 temporalAtMin = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer r = functions.temporal_at_min(ptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Value-set restriction — at/minus a set of values + // ------------------------------------------------------------------ + + // temporalAtValues(s STRING, setHex STRING) → STRING + // MEOS: temporal_at_values(const Temporal *, const Set *) → Temporal * + // setHex is an intset/floatset/textset/etc. in hex-WKB form. + public static final UDF2 temporalAtValues = + (s, setHex) -> { + if (s == null || setHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer setPtr = functions.set_from_hexwkb(setHex); + if (setPtr == null) return null; + try { + Pointer result = functions.temporal_at_values(tptr, setPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(setPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalMinusValues(s STRING, setHex STRING) → STRING + // MEOS: temporal_minus_values(const Temporal *, const Set *) → Temporal * + public static final UDF2 temporalMinusValues = + (s, setHex) -> { + if (s == null || setHex == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer setPtr = functions.set_from_hexwkb(setHex); + if (setPtr == null) return null; + try { + Pointer result = functions.temporal_minus_values(tptr, setPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(setPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Spatial restriction — at/minus geometry + // ------------------------------------------------------------------ + + // tgeoAtGeom(s STRING, geomWkt STRING) → STRING + // MEOS: tgeo_at_geom(const Temporal *, const GSERIALIZED *) → Temporal * + public static final UDF2 tgeoAtGeom = + (s, geomWkt) -> { + if (s == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) return null; + try { + Pointer r = functions.tgeo_at_geom(tptr, gsptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(gsptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // tgeoMinusGeom(s STRING, geomWkt STRING) → STRING + // MEOS: tgeo_minus_geom(const Temporal *, const GSERIALIZED *) → Temporal * + public static final UDF2 tgeoMinusGeom = + (s, geomWkt) -> { + if (s == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer gsptr = functions.geo_from_text(geomWkt, 0); + if (gsptr == null) return null; + try { + Pointer r = functions.tgeo_minus_geom(tptr, gsptr); + if (r == null) return null; + try { + return functions.temporal_as_hexwkb(r, (byte) 0); + } finally { + MeosMemory.free(r); + } + } finally { + MeosMemory.free(gsptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Registration + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // Timestamp-span/spanset restriction + spark.udf().register("temporalAtTstzspan", temporalAtTstzspan, DataTypes.StringType); + spark.udf().register("temporalAtTstzspanset", temporalAtTstzspanset, DataTypes.StringType); + // Timestamp-set restriction + spark.udf().register("temporalAtTstzset", temporalAtTstzset, DataTypes.StringType); + spark.udf().register("temporalMinusTstzset", temporalMinusTstzset, DataTypes.StringType); + spark.udf().register("temporalMinusTstzspan", temporalMinusTstzspan, DataTypes.StringType); + spark.udf().register("temporalMinusTstzspanset", temporalMinusTstzspanset, DataTypes.StringType); + // Single-timestamptz restriction + spark.udf().register("temporalAtTimestamptz", temporalAtTimestamptz, DataTypes.StringType); + spark.udf().register("temporalMinusTimestamptz", temporalMinusTimestamptz, DataTypes.StringType); + // Delete operations + spark.udf().register("temporalDeleteTstzspan", temporalDeleteTstzspan, DataTypes.StringType); + spark.udf().register("temporalDeleteTstzspanset", temporalDeleteTstzspanset, DataTypes.StringType); + spark.udf().register("temporalDeleteTstzset", temporalDeleteTstzset, DataTypes.StringType); + spark.udf().register("temporalDeleteTimestamptz", temporalDeleteTimestamptz, DataTypes.StringType); + // Value restriction: tfloat / tint + spark.udf().register("tfloatAtValue", tfloatAtValue, DataTypes.StringType); + spark.udf().register("tfloatMinusValue", tfloatMinusValue, DataTypes.StringType); + spark.udf().register("tintAtValue", tintAtValue, DataTypes.StringType); + spark.udf().register("tintMinusValue", tintMinusValue, DataTypes.StringType); + // Value-range restriction: tnumber + spark.udf().register("tnumberAtSpan", tnumberAtSpan, DataTypes.StringType); + spark.udf().register("tnumberMinusSpan", tnumberMinusSpan, DataTypes.StringType); + spark.udf().register("tnumberAtSpanset", tnumberAtSpanset, DataTypes.StringType); + spark.udf().register("tnumberMinusSpanset", tnumberMinusSpanset, DataTypes.StringType); + // Value restriction: tbool + spark.udf().register("tboolAtValue", tboolAtValue, DataTypes.StringType); + spark.udf().register("tboolMinusValue", tboolMinusValue, DataTypes.StringType); + // Value restriction: ttext + spark.udf().register("ttextAtValue", ttextAtValue, DataTypes.StringType); + spark.udf().register("ttextMinusValue", ttextMinusValue, DataTypes.StringType); + // Value restriction: tpoint + spark.udf().register("tpointAtValue", tpointAtValue, DataTypes.StringType); + spark.udf().register("tpointMinusValue", tpointMinusValue, DataTypes.StringType); + // STBox and elevation restriction + spark.udf().register("tgeoAtStbox", tgeoAtStbox, DataTypes.StringType); + spark.udf().register("tgeoMinusStbox", tgeoMinusStbox, DataTypes.StringType); + spark.udf().register("tpointAtElevation", tpointAtElevation, DataTypes.StringType); + spark.udf().register("tpointMinusElevation", tpointMinusElevation, DataTypes.StringType); + // Extrema restriction + spark.udf().register("temporalAtMax", temporalAtMax, DataTypes.StringType); + spark.udf().register("temporalAtMin", temporalAtMin, DataTypes.StringType); + // Value-set restriction + spark.udf().register("temporalAtValues", temporalAtValues, DataTypes.StringType); + spark.udf().register("temporalMinusValues", temporalMinusValues, DataTypes.StringType); + // Spatial restriction + spark.udf().register("tgeoAtGeom", tgeoAtGeom, DataTypes.StringType); + spark.udf().register("tgeoMinusGeom", tgeoMinusGeom, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SeqSetGapsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SeqSetGapsUDFs.java new file mode 100644 index 00000000..126bf169 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SeqSetGapsUDFs.java @@ -0,0 +1,147 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.api.java.UDF4; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for the SeqSetGaps constructor family — long-standing + * user request from MobilityDB issue #187. + * + * Constructs a temporal sequence-set from an array of temporal instants + * accounting for gaps: consecutive instants further apart than {@code maxt} + * (in time) or {@code maxdist} (in value space, for tnumber/tpoint) start + * a new sequence within the resulting sequence-set. + * + * MEOS function authority: tsequenceset_make_gaps in meos/include/meos.h. + * + * Per-type variants set the default interpolation: + * - tbool/tint/ttext: STEP (=2) + * - tfloat/tgeompoint/tgeogpoint/tgeometry/tgeography: LINEAR (=3) + */ +public final class SeqSetGapsUDFs { + + private SeqSetGapsUDFs() {} + + private static final int INTERP_STEP = 2; + private static final int INTERP_LINEAR = 3; + + /** + * Core builder: deserialise N temporal-instant hex strings, pack their + * pointers into a native TInstant** buffer, call tsequenceset_make_gaps, + * serialise the result, free everything. + */ + private static String build(String[] instants, String maxtStr, double maxdist, int interp) { + if (instants == null || instants.length == 0) return null; + MeosThread.ensureReady(); + + int n = instants.length; + Pointer[] insts = new Pointer[n]; + try { + for (int i = 0; i < n; i++) { + if (instants[i] == null) return null; + insts[i] = functions.temporal_from_hexwkb(instants[i]); + if (insts[i] == null) return null; + } + Pointer buf = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8L * n); + for (int i = 0; i < n; i++) { + buf.putAddress(i * 8L, insts[i].address()); + } + Pointer maxt = (maxtStr == null) ? null : functions.pg_interval_in(maxtStr, -1); + try { + Pointer r = functions.tsequenceset_make_gaps(buf, n, interp, maxt, maxdist); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { + if (maxt != null) MeosMemory.free(maxt); + } + } finally { + for (Pointer p : insts) { + if (p != null) MeosMemory.free(p); + } + } + } + + // tboolSeqSetGaps(tbool[], maxt) — STEP interpolation, no maxdist + public static final UDF2 tboolSeqSetGaps = + (instants, maxt) -> build(instants, maxt, -1.0, INTERP_STEP); + + // ttextSeqSetGaps(ttext[], maxt) — STEP, no maxdist + public static final UDF2 ttextSeqSetGaps = + (instants, maxt) -> build(instants, maxt, -1.0, INTERP_STEP); + + // tintSeqSetGaps(tint[], maxt, maxdist) — STEP, optional maxdist + public static final UDF3 tintSeqSetGaps = + (instants, maxt, maxdist) -> build(instants, maxt, + maxdist == null ? -1.0 : maxdist, INTERP_STEP); + + // tfloatSeqSetGaps(tfloat[], maxt, maxdist, interpStr) — LINEAR default + public static final UDF4 tfloatSeqSetGaps = + (instants, maxt, maxdist, interpStr) -> build(instants, maxt, + maxdist == null ? -1.0 : maxdist, parseInterp(interpStr, INTERP_LINEAR)); + + // tgeompointSeqSetGaps / tgeogpointSeqSetGaps / tgeometrySeqSetGaps / + // tgeographySeqSetGaps — LINEAR default, optional maxdist + interp string + public static final UDF4 tgeompointSeqSetGaps = + (instants, maxt, maxdist, interpStr) -> build(instants, maxt, + maxdist == null ? -1.0 : maxdist, parseInterp(interpStr, INTERP_LINEAR)); + + public static final UDF4 tgeogpointSeqSetGaps = tgeompointSeqSetGaps; + public static final UDF4 tgeometrySeqSetGaps = tgeompointSeqSetGaps; + public static final UDF4 tgeographySeqSetGaps = tgeompointSeqSetGaps; + + private static int parseInterp(String s, int dflt) { + if (s == null) return dflt; + switch (s.toLowerCase()) { + case "linear": return INTERP_LINEAR; + case "step": return INTERP_STEP; + case "discrete": return 1; + default: return dflt; + } + } + + public static void registerAll(SparkSession spark) { + spark.udf().register("tboolSeqSetGaps", tboolSeqSetGaps, DataTypes.StringType); + spark.udf().register("ttextSeqSetGaps", ttextSeqSetGaps, DataTypes.StringType); + spark.udf().register("tintSeqSetGaps", tintSeqSetGaps, DataTypes.StringType); + spark.udf().register("tfloatSeqSetGaps", tfloatSeqSetGaps, DataTypes.StringType); + spark.udf().register("tgeompointSeqSetGaps", tgeompointSeqSetGaps, DataTypes.StringType); + spark.udf().register("tgeogpointSeqSetGaps", tgeogpointSeqSetGaps, DataTypes.StringType); + spark.udf().register("tgeometrySeqSetGaps", tgeometrySeqSetGaps, DataTypes.StringType); + spark.udf().register("tgeographySeqSetGaps", tgeographySeqSetGaps, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SetOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SetOpsUDFs.java new file mode 100644 index 00000000..ca31af77 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SetOpsUDFs.java @@ -0,0 +1,130 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for set × set positional, topological, and distance + * operations. Set hex carries the element type so a single UDF dispatches + * across all set types. + * + * MEOS function authority: meos/include/meos.h + */ +public final class SetOpsUDFs { + + private SetOpsUDFs() {} + + private static UDF2 setSet(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.set_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.set_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + public static final UDF2 setLeft = setSet(functions::left_set_set); + public static final UDF2 setRight = setSet(functions::right_set_set); + public static final UDF2 setOverleft = setSet(functions::overleft_set_set); + public static final UDF2 setOverright = setSet(functions::overright_set_set); + public static final UDF2 setContains = setSet(functions::contains_set_set); + public static final UDF2 setContained = setSet(functions::contained_set_set); + public static final UDF2 setOverlaps = setSet(functions::overlaps_set_set); + + // Per-type distance (set×set must be of matching element type). + public static final UDF2 distanceIntsetIntset = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.set_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.set_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return functions.distance_intset_intset(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + + public static final UDF2 distanceBigintsetBigintset = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.set_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.set_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return functions.distance_bigintset_bigintset(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + + public static final UDF2 distanceFloatsetFloatset = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.set_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.set_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return functions.distance_floatset_floatset(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + + public static final UDF2 distanceTstzsetTstzset = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.set_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.set_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return functions.distance_tstzset_tstzset(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("setLeft", setLeft, DataTypes.BooleanType); + spark.udf().register("setRight", setRight, DataTypes.BooleanType); + spark.udf().register("setOverleft", setOverleft, DataTypes.BooleanType); + spark.udf().register("setOverright", setOverright, DataTypes.BooleanType); + spark.udf().register("setContains", setContains, DataTypes.BooleanType); + spark.udf().register("setContained", setContained, DataTypes.BooleanType); + spark.udf().register("setOverlaps", setOverlaps, DataTypes.BooleanType); + + spark.udf().register("distanceIntsetIntset", distanceIntsetIntset, DataTypes.IntegerType); + spark.udf().register("distanceBigintsetBigintset", distanceBigintsetBigintset, DataTypes.LongType); + spark.udf().register("distanceFloatsetFloatset", distanceFloatsetFloatset, DataTypes.DoubleType); + spark.udf().register("distanceTstzsetTstzset", distanceTstzsetTstzset, DataTypes.DoubleType); + // MobilityDB SQL bare-name aliases + spark.udf().register("setDistance", distanceFloatsetFloatset, DataTypes.DoubleType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SimilarityUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SimilarityUDFs.java new file mode 100644 index 00000000..d4ea25d8 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SimilarityUDFs.java @@ -0,0 +1,191 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for trajectory similarity measures. + * + * Both measures operate on any pair of temporal values with the same base type + * (tgeompoint × tgeompoint, tfloat × tfloat, etc.) and return a scalar Double. + * + * MEOS function authority: meos/include/meos.h (038_temporal_similarity) + */ +public final class SimilarityUDFs { + + private SimilarityUDFs() {} + + // ------------------------------------------------------------------ + // frechetDistance(t1 STRING, t2 STRING) → DOUBLE + // + // Discrete Fréchet distance between two temporal trajectories. + // Returns null when the inputs have incompatible types or no instants. + // + // MEOS: temporal_frechet_distance(const Temporal *, const Temporal *) → double + // ------------------------------------------------------------------ + public static final UDF2 frechetDistance = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + double d = functions.temporal_frechet_distance(p1, p2); + return (d == Double.MAX_VALUE) ? null : d; + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // dynamicTimeWarp(t1 STRING, t2 STRING) → DOUBLE + // + // Dynamic Time Warping distance between two temporal trajectories. + // Returns null when the inputs have incompatible types or no instants. + // + // MEOS: temporal_dyntimewarp_distance(const Temporal *, const Temporal *) → double + // ------------------------------------------------------------------ + public static final UDF2 dynamicTimeWarp = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + double d = functions.temporal_dyntimewarp_distance(p1, p2); + return (d == Double.MAX_VALUE) ? null : d; + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // hausdorffDistance(t1 STRING, t2 STRING) → DOUBLE + // + // Hausdorff distance between two temporal trajectories. + // Returns null when the inputs have incompatible types or no instants. + // + // MEOS: temporal_hausdorff_distance(const Temporal *, const Temporal *) → double + // ------------------------------------------------------------------ + public static final UDF2 hausdorffDistance = + (s1, s2) -> { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(s1); + if (p1 == null) return null; + try { + Pointer p2 = functions.temporal_from_hexwkb(s2); + if (p2 == null) return null; + try { + double d = functions.temporal_hausdorff_distance(p1, p2); + return (d == Double.MAX_VALUE) ? null : d; + } finally { MeosMemory.free(p2); } + } finally { MeosMemory.free(p1); } + }; + + // ------------------------------------------------------------------ + // REGISTRATION + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + spark.udf().register("frechetDistance", frechetDistance, DataTypes.DoubleType); + spark.udf().register("dynamicTimeWarp", dynamicTimeWarp, DataTypes.DoubleType); + spark.udf().register("hausdorffDistance", hausdorffDistance, DataTypes.DoubleType); + // MobilityDB SQL bare-name alias for dynamicTimeWarp + spark.udf().register("dynTimeWarpDistance", dynamicTimeWarp, DataTypes.DoubleType); + // Similarity paths — return array of "i,j" pairs as Strings + spark.udf().register("dynTimeWarpPath", dynTimeWarpPath, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("frechetDistancePath", frechetDistancePath, DataTypes.createArrayType(DataTypes.StringType)); + } + + // dynTimeWarpPath / frechetDistancePath: return array of "i,j" pairs + + public static final org.apache.spark.sql.api.java.UDF2 dynTimeWarpPath = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer p1 = functions.temporal_from_hexwkb(h1); + if (p1 == null) return null; + jnr.ffi.Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { org.mobilitydb.spark.MeosMemory.free(p1); return null; } + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + jnr.ffi.Pointer countOut = rt.getMemoryManager().allocateDirect(4); + jnr.ffi.Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_dyntimewarp_path(p1, p2, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + // Match = {int i, int j} — 8 bytes each + int mi = arr.getInt(i * 8L); + int mj = arr.getInt(i * 8L + 4); + out[i] = mi + "," + mj; + } + return out; + } finally { org.mobilitydb.spark.MeosMemory.free(arr); } + } finally { org.mobilitydb.spark.MeosMemory.free(p1, p2); } + }; + + public static final org.apache.spark.sql.api.java.UDF2 frechetDistancePath = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + org.mobilitydb.spark.MeosThread.ensureReady(); + jnr.ffi.Pointer p1 = functions.temporal_from_hexwkb(h1); + if (p1 == null) return null; + jnr.ffi.Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { org.mobilitydb.spark.MeosMemory.free(p1); return null; } + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + jnr.ffi.Pointer countOut = rt.getMemoryManager().allocateDirect(4); + jnr.ffi.Pointer arr = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_frechet_path(p1, p2, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + int mi = arr.getInt(i * 8L); + int mj = arr.getInt(i * 8L + 4); + out[i] = mi + "," + mj; + } + return out; + } finally { org.mobilitydb.spark.MeosMemory.free(arr); } + } finally { org.mobilitydb.spark.MeosMemory.free(p1, p2); } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SpanAccessorUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SpanAccessorUDFs.java new file mode 100644 index 00000000..d47aafd9 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SpanAccessorUDFs.java @@ -0,0 +1,814 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.time.OffsetDateTime; +import java.util.ArrayList; +import java.util.List; + +/** + * Spark SQL UDFs for span, spanset, and set bound/count accessors. + * + * MEOS function authority: meos/include/meos.h + */ +public final class SpanAccessorUDFs { + + private SpanAccessorUDFs() {} + + // milliseconds from Unix epoch (1970-01-01) to PG epoch (2000-01-01) + private static final long PG_UNIX_OFFSET_MS = 946684800L * 1000L; + // days from Unix epoch (1970-01-01) to PG epoch (2000-01-01) + private static final long PG_UNIX_OFFSET_DAYS = 10957L; + + // tstzspan_lower/upper returns OffsetDateTime where toEpochSecond() + // holds raw PG-epoch microseconds; divide by 1000 then add PG→Unix offset + private static java.sql.Timestamp odtToTimestamp(OffsetDateTime odt) { + if (odt == null) return null; + return new java.sql.Timestamp(odt.toEpochSecond() / 1000L + PG_UNIX_OFFSET_MS); + } + + // ------------------------------------------------------------------ + // intspan accessors + // ------------------------------------------------------------------ + + public static final UDF1 intspanLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.intspan_lower(p); + }; + + public static final UDF1 intspanUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.intspan_upper(p); + }; + + public static final UDF1 intspanWidth = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.intspan_width(p); + }; + + // ------------------------------------------------------------------ + // floatspan accessors + // ------------------------------------------------------------------ + + public static final UDF1 floatspanLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.floatspan_lower(p); + }; + + public static final UDF1 floatspanUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.floatspan_upper(p); + }; + + public static final UDF1 floatspanWidth = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.floatspan_width(p); + }; + + // ------------------------------------------------------------------ + // bigintspan accessors + // ------------------------------------------------------------------ + + public static final UDF1 bigintspanLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.bigintspan_lower(p); + }; + + public static final UDF1 bigintspanUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.bigintspan_upper(p); + }; + + // ------------------------------------------------------------------ + // datespan accessors (MEOS returns int = days from PG epoch 2000-01-01) + // ------------------------------------------------------------------ + + public static final UDF1 datespanLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + int days = functions.datespan_lower(p); + return new java.sql.Date((days + PG_UNIX_OFFSET_DAYS) * 86400000L); + }; + + public static final UDF1 datespanUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + int days = functions.datespan_upper(p); + return new java.sql.Date((days + PG_UNIX_OFFSET_DAYS) * 86400000L); + }; + + // ------------------------------------------------------------------ + // tstzspan accessors + // ------------------------------------------------------------------ + + public static final UDF1 tstzspanLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspan_lower(p)); + }; + + public static final UDF1 tstzspanUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspan_upper(p)); + }; + + // ------------------------------------------------------------------ + // Generic span inclusivity flags + // ------------------------------------------------------------------ + + public static final UDF1 spanLowerInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.span_lower_inc(p); + }; + + public static final UDF1 spanUpperInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + return functions.span_upper_inc(p); + }; + + // ------------------------------------------------------------------ + // Spanset accessors + // ------------------------------------------------------------------ + + public static final UDF1 spansetNumSpans = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return functions.spanset_num_spans(p); + }; + + public static final UDF1 spansetStartSpan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + Pointer span = functions.spanset_start_span(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + public static final UDF1 spansetEndSpan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + Pointer span = functions.spanset_end_span(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Spanset inclusivity flags + // ------------------------------------------------------------------ + + // spansetLowerInc(hex STRING) → BOOLEAN (lower bound of the first span) + // MEOS: spanset_lower_inc(const SpanSet *) → bool + public static final UDF1 spansetLowerInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return functions.spanset_lower_inc(p); + }; + + // spansetUpperInc(hex STRING) → BOOLEAN (upper bound of the last span) + // MEOS: spanset_upper_inc(const SpanSet *) → bool + public static final UDF1 spansetUpperInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return functions.spanset_upper_inc(p); + }; + + // ------------------------------------------------------------------ + // Span-to-spanset conversion + // ------------------------------------------------------------------ + + // spanToSpanset(hex STRING) → STRING (wrap a span in a single-element spanset) + // MEOS: span_to_spanset(const Span *) → SpanSet * + public static final UDF1 spanToSpanset = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + Pointer ss = functions.span_to_spanset(p); + if (ss == null) return null; + return functions.spanset_as_hexwkb(ss, (byte) 0); + }; + + // ------------------------------------------------------------------ + // TstzSpanSet temporal boundary accessors + // + // MEOS: tstzspanset_lower, tstzspanset_upper, + // tstzspanset_start_timestamptz, tstzspanset_end_timestamptz + // All return OffsetDateTime (PG-epoch microseconds via toEpochSecond()). + // ------------------------------------------------------------------ + + public static final UDF1 tstzspansetLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspanset_lower(p)); + }; + + public static final UDF1 tstzspansetUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspanset_upper(p)); + }; + + public static final UDF1 tstzspansetStartTimestamptz = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspanset_start_timestamptz(p)); + }; + + public static final UDF1 tstzspansetEndTimestamptz = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + return odtToTimestamp(functions.tstzspanset_end_timestamptz(p)); + }; + + // ------------------------------------------------------------------ + // Set accessors + // ------------------------------------------------------------------ + + public static final UDF1 setNumValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + return functions.set_num_values(p); + }; + + // ------------------------------------------------------------------ + // intset value accessors + // ------------------------------------------------------------------ + + public static final UDF1 intsetStartValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intset_start_value(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 intsetEndValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intset_end_value(p); } + finally { MeosMemory.free(p); } + }; + + // intset_values(Set *) → int * (palloc'd int32 array, count via set_num_values) + public static final UDF1> intsetValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Pointer arr = functions.intset_values(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) result.add(arr.getInt((long) i * 4)); + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // floatset value accessors + // ------------------------------------------------------------------ + + public static final UDF1 floatsetStartValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.floatset_start_value(p); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 floatsetEndValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return functions.floatset_end_value(p); } + finally { MeosMemory.free(p); } + }; + + // floatset_values(Set *) → double * + public static final UDF1> floatsetValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Pointer arr = functions.floatset_values(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) result.add(arr.getDouble((long) i * 8)); + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // dateset value accessors (int32 = days from PG epoch 2000-01-01) + // ------------------------------------------------------------------ + + public static final UDF1 datesetStartValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int days = functions.dateset_start_value(p); + return new java.sql.Date((days + PG_UNIX_OFFSET_DAYS) * 86400000L); + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 datesetEndValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int days = functions.dateset_end_value(p); + return new java.sql.Date((days + PG_UNIX_OFFSET_DAYS) * 86400000L); + } finally { MeosMemory.free(p); } + }; + + // dateset_values(Set *) → int * (int32 days from PG epoch per element) + public static final UDF1> datesetValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Pointer arr = functions.dateset_values(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + int days = arr.getInt((long) i * 4); + result.add(new java.sql.Date((days + PG_UNIX_OFFSET_DAYS) * 86400000L)); + } + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // tstzset value accessors + // ------------------------------------------------------------------ + + public static final UDF1 tstzsetStartValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return odtToTimestamp(functions.tstzset_start_value(p)); } + finally { MeosMemory.free(p); } + }; + + public static final UDF1 tstzsetEndValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { return odtToTimestamp(functions.tstzset_end_value(p)); } + finally { MeosMemory.free(p); } + }; + + // tstzset_values(Set *) → int64 * (PG-epoch microseconds per element) + public static final UDF1> tstzsetValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Pointer arr = functions.tstzset_values(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + long pgMicros = arr.getLong((long) i * 8); + result.add(new java.sql.Timestamp(pgMicros / 1000L + PG_UNIX_OFFSET_MS)); + } + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // textset value accessors (text * elements → String via text_out) + // ------------------------------------------------------------------ + + public static final UDF1 textsetStartValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer textPtr = functions.textset_start_value(p); + if (textPtr == null) return null; + return functions.text_out(textPtr); + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 textsetEndValue = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer textPtr = functions.textset_end_value(p); + if (textPtr == null) return null; + return functions.text_out(textPtr); + } finally { MeosMemory.free(p); } + }; + + // textset_values(Set *) → text ** (pointer array; elements are views — do NOT free) + public static final UDF1> textsetValues = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.set_num_values(p); + Pointer arr = functions.textset_values(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + Pointer textPtr = arr.getPointer((long) i * 8); + if (textPtr != null) result.add(functions.text_out(textPtr)); + } + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + public static void registerAll(SparkSession spark) { + spark.udf().register("intspanLower", intspanLower, DataTypes.IntegerType); + spark.udf().register("intspanUpper", intspanUpper, DataTypes.IntegerType); + spark.udf().register("intspanWidth", intspanWidth, DataTypes.IntegerType); + spark.udf().register("floatspanLower", floatspanLower, DataTypes.DoubleType); + spark.udf().register("floatspanUpper", floatspanUpper, DataTypes.DoubleType); + spark.udf().register("floatspanWidth", floatspanWidth, DataTypes.DoubleType); + spark.udf().register("bigintspanLower", bigintspanLower, DataTypes.LongType); + spark.udf().register("bigintspanUpper", bigintspanUpper, DataTypes.LongType); + spark.udf().register("datespanLower", datespanLower, DataTypes.DateType); + spark.udf().register("datespanUpper", datespanUpper, DataTypes.DateType); + spark.udf().register("tstzspanLower", tstzspanLower, DataTypes.TimestampType); + spark.udf().register("tstzspanUpper", tstzspanUpper, DataTypes.TimestampType); + spark.udf().register("spanLowerInc", spanLowerInc, DataTypes.BooleanType); + spark.udf().register("spanUpperInc", spanUpperInc, DataTypes.BooleanType); + spark.udf().register("spansetNumSpans", spansetNumSpans, DataTypes.IntegerType); + spark.udf().register("spansetStartSpan", spansetStartSpan, DataTypes.StringType); + spark.udf().register("spansetEndSpan", spansetEndSpan, DataTypes.StringType); + spark.udf().register("spansetLowerInc", spansetLowerInc, DataTypes.BooleanType); + spark.udf().register("spansetUpperInc", spansetUpperInc, DataTypes.BooleanType); + spark.udf().register("spanToSpanset", spanToSpanset, DataTypes.StringType); + spark.udf().register("setNumValues", setNumValues, DataTypes.IntegerType); + // intset value accessors + spark.udf().register("intsetStartValue", intsetStartValue, DataTypes.IntegerType); + spark.udf().register("intsetEndValue", intsetEndValue, DataTypes.IntegerType); + spark.udf().register("intsetValues", intsetValues, + DataTypes.createArrayType(DataTypes.IntegerType)); + // floatset value accessors + spark.udf().register("floatsetStartValue", floatsetStartValue, DataTypes.DoubleType); + spark.udf().register("floatsetEndValue", floatsetEndValue, DataTypes.DoubleType); + spark.udf().register("floatsetValues", floatsetValues, + DataTypes.createArrayType(DataTypes.DoubleType)); + // dateset value accessors + spark.udf().register("datesetStartValue", datesetStartValue, DataTypes.DateType); + spark.udf().register("datesetEndValue", datesetEndValue, DataTypes.DateType); + spark.udf().register("datesetValues", datesetValues, + DataTypes.createArrayType(DataTypes.DateType)); + // tstzset value accessors + spark.udf().register("tstzsetStartValue", tstzsetStartValue, DataTypes.TimestampType); + spark.udf().register("tstzsetEndValue", tstzsetEndValue, DataTypes.TimestampType); + spark.udf().register("tstzsetValues", tstzsetValues, + DataTypes.createArrayType(DataTypes.TimestampType)); + // textset value accessors + spark.udf().register("textsetStartValue", textsetStartValue, DataTypes.StringType); + spark.udf().register("textsetEndValue", textsetEndValue, DataTypes.StringType); + spark.udf().register("textsetValues", textsetValues, + DataTypes.createArrayType(DataTypes.StringType)); + // TstzSpanSet temporal boundary accessors + spark.udf().register("tstzspansetLower", tstzspansetLower, DataTypes.TimestampType); + spark.udf().register("tstzspansetUpper", tstzspansetUpper, DataTypes.TimestampType); + spark.udf().register("tstzspansetStartTimestamptz", tstzspansetStartTimestamptz, DataTypes.TimestampType); + spark.udf().register("tstzspansetEndTimestamptz", tstzspansetEndTimestamptz, DataTypes.TimestampType); + // spanset nth-span accessor + spark.udf().register("spansetSpanN", spansetSpanN, DataTypes.StringType); + // intspanset / floatspanset bound accessors + spark.udf().register("intspansetLower", intspansetLower, DataTypes.IntegerType); + spark.udf().register("intspansetUpper", intspansetUpper, DataTypes.IntegerType); + spark.udf().register("intspansetWidth", intspansetWidth, DataTypes.IntegerType); + spark.udf().register("floatspansetLower", floatspansetLower, DataTypes.DoubleType); + spark.udf().register("floatspansetUpper", floatspansetUpper, DataTypes.DoubleType); + spark.udf().register("floatspansetWidth", floatspansetWidth, DataTypes.DoubleType); + // tstzspanset extra accessors + spark.udf().register("tstzspansetNumTimestamps", tstzspansetNumTimestamps, DataTypes.IntegerType); + spark.udf().register("tstzspansetTimestamps", tstzspansetTimestamps, + DataTypes.createArrayType(DataTypes.TimestampType)); + spark.udf().register("tstzspansetDuration", tstzspansetDuration, DataTypes.StringType); + } + + // ------------------------------------------------------------------ + // ------------------------------------------------------------------ + // intspanset / floatspanset bound accessors + // ------------------------------------------------------------------ + + // intspansetLower(hex STRING) → INTEGER + // MEOS: intspanset_lower(const SpanSet *) → int + public static final UDF1 intspansetLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intspanset_lower(p); } + finally { MeosMemory.free(p); } + }; + + // intspansetUpper(hex STRING) → INTEGER + // MEOS: intspanset_upper(const SpanSet *) → int + public static final UDF1 intspansetUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.intspanset_upper(p); } + finally { MeosMemory.free(p); } + }; + + // intspansetWidth(hex STRING, ignoreGaps BOOLEAN) → INTEGER + // MEOS: intspanset_width(const SpanSet *, bool) → int + public static final UDF2 intspansetWidth = + (hex, ignoreGaps) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + return functions.intspanset_width(p, ignoreGaps != null && ignoreGaps); + } finally { MeosMemory.free(p); } + }; + + // floatspansetLower(hex STRING) → DOUBLE + // Workaround: floatspanset_lower in MEOS uses Float8GetDatum (wrong direction), + // so we extract the first span and use floatspan_lower which is correct. + public static final UDF1 floatspansetLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer firstSpan = functions.spanset_start_span(p); + if (firstSpan == null) return null; + return functions.floatspan_lower(firstSpan); + } finally { MeosMemory.free(p); } + }; + + // floatspansetUpper(hex STRING) → DOUBLE + // Workaround: same Float8GetDatum bug as floatspanset_lower. + // Uses spanset_end_span + floatspan_upper instead. + public static final UDF1 floatspansetUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer lastSpan = functions.spanset_end_span(p); + if (lastSpan == null) return null; + return functions.floatspan_upper(lastSpan); + } finally { MeosMemory.free(p); } + }; + + // floatspansetWidth(hex STRING, ignoreGaps BOOLEAN) → DOUBLE + // MEOS: floatspanset_width(const SpanSet *, bool) → double + public static final UDF2 floatspansetWidth = + (hex, ignoreGaps) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + return functions.floatspanset_width(p, ignoreGaps != null && ignoreGaps); + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // tstzspanset extra accessors + // ------------------------------------------------------------------ + + // tstzspansetNumTimestamps(hex STRING) → INTEGER + // MEOS: tstzspanset_num_timestamps(const SpanSet *) → int + public static final UDF1 tstzspansetNumTimestamps = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { return functions.tstzspanset_num_timestamps(p); } + finally { MeosMemory.free(p); } + }; + + // tstzspansetTimestamps(hex STRING) → ARRAY + // MEOS: tstzspanset_timestamps(const SpanSet *) → TimestampTz * + // Returns int64* array (PG-epoch microseconds); count via tstzspanset_num_timestamps. + public static final UDF1> tstzspansetTimestamps = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + int n = functions.tstzspanset_num_timestamps(p); + Pointer arr = functions.tstzspanset_timestamps(p); + if (arr == null) return null; + try { + List result = new ArrayList<>(n); + for (int i = 0; i < n; i++) { + long pgMicros = arr.getLong((long) i * 8); + result.add(new java.sql.Timestamp(pgMicros / 1000L + PG_UNIX_OFFSET_MS)); + } + return result; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(p); } + }; + + // tstzspansetDuration(hex STRING, ignoreGaps BOOLEAN) → STRING (interval) + // MEOS: tstzspanset_duration(const SpanSet *, bool) → Interval * + public static final UDF2 tstzspansetDuration = + (hex, ignoreGaps) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + boolean ignore = (ignoreGaps != null && ignoreGaps); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer iv = functions.tstzspanset_duration(p, ignore); + if (iv == null) return null; + try { return functions.pg_interval_out(iv); } + finally { MeosMemory.free(iv); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // spanset_span_n(spanset, n) → span hex-WKB (1-based index) + // MEOS: spanset_span_n(SpanSet *, int) → Span * (view — must NOT free) + // ------------------------------------------------------------------ + + public static final UDF2 spansetSpanN = + (hex, n) -> { + if (hex == null || n == null) return null; + MeosThread.ensureReady(); + Pointer ss = functions.spanset_from_hexwkb(hex); + if (ss == null) return null; + try { + Pointer span = functions.spanset_span_n(ss, n); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + } finally { + MeosMemory.free(ss); + } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFs.java new file mode 100644 index 00000000..a35ff1a7 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFs.java @@ -0,0 +1,817 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for span and set topology predicates and algebraic operations. + * + * All inputs and outputs use hex-WKB string encoding (the internal MobilitySpark + * storage format). Set-returning operations (union, minus) produce a SpanSet + * hex-WKB; intersection returns a Span hex-WKB (null when disjoint). + * + * Naming convention: camelCase to avoid conflicts with Spark built-ins. + * + * MEOS function authority: meos/include/meos.h + */ +public final class SpanAlgebraUDFs { + + private SpanAlgebraUDFs() {} + + // ------------------------------------------------------------------ + // Helper: parse hex-WKB string → span Pointer + // ------------------------------------------------------------------ + private static Pointer spanPtr(String hex) { + return hex == null ? null : functions.span_from_hexwkb(hex); + } + + private static Pointer spansetPtr(String hex) { + return hex == null ? null : functions.spanset_from_hexwkb(hex); + } + + private static Pointer setPtr(String hex) { + return hex == null ? null : functions.set_from_hexwkb(hex); + } + + // ------------------------------------------------------------------ + // Span topology predicates (span, span) → Boolean + // + // MEOS: contains_span_span / contained_span_span / overlaps_span_span + // adjacent_span_span / left_span_span / right_span_span + // overleft_span_span / overright_span_span + // ------------------------------------------------------------------ + + // spanContains("[1,10)", "[2,5)") → true + public static final UDF2 spanContains = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.contains_span_span(p1, p2); + }; + + // spanContainedIn("[2,5)", "[1,10)") → true + public static final UDF2 spanContainedIn = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.contained_span_span(p1, p2); + }; + + // spanOverlaps("[1,5)", "[3,10)") → true + public static final UDF2 spanOverlaps = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.overlaps_span_span(p1, p2); + }; + + // spanAdjacent("[1,5)", "[5,10)") → true + public static final UDF2 spanAdjacent = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.adjacent_span_span(p1, p2); + }; + + // spanLeft("[1,5)", "[6,10)") → true + public static final UDF2 spanLeft = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.left_span_span(p1, p2); + }; + + // spanRight("[6,10)", "[1,5)") → true + public static final UDF2 spanRight = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.right_span_span(p1, p2); + }; + + // spanOverleft("[1,5)", "[3,10)") → true (s1 does not extend right of s2) + public static final UDF2 spanOverleft = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.overleft_span_span(p1, p2); + }; + + // spanOverright("[3,10)", "[1,5)") → true (s1 does not extend left of s2) + public static final UDF2 spanOverright = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.overright_span_span(p1, p2); + }; + + // ------------------------------------------------------------------ + // Span algebraic operations (span, span) → hex-WKB STRING + // + // MEOS: union_span_span → SpanSet * + // intersection_span_span → Span * (null when disjoint) + // minus_span_span → SpanSet * + // ------------------------------------------------------------------ + + // spanUnion("[1,5)", "[3,10)") → "{[1,10)}" (SpanSet hex-WKB) + public static final UDF2 spanUnion = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer ss = functions.union_span_span(p1, p2); + if (ss == null) return null; + return functions.spanset_as_hexwkb(ss, (byte) 0); + }; + + // spanIntersection("[1,10)", "[3,7)") → "[3,7)" (Span hex-WKB; null if disjoint) + public static final UDF2 spanIntersection = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer s = functions.intersection_span_span(p1, p2); + if (s == null) return null; + return functions.span_as_hexwkb(s, (byte) 0); + }; + + // spanMinus("[1,10)", "[3,7)") → "{[1,3),[7,10)}" (SpanSet hex-WKB) + public static final UDF2 spanMinus = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer ss = functions.minus_span_span(p1, p2); + if (ss == null) return null; + return functions.spanset_as_hexwkb(ss, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Tstzspan distance (tstzspan, tstzspan) → Double (seconds) + // + // MEOS: distance_tstzspan_tstzspan → double + // ------------------------------------------------------------------ + + // tstzspanDistance("[2020-01-01, 2020-01-05)", "[2020-01-10, 2020-01-15)") → 432000.0 + public static final UDF2 tstzspanDistance = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.distance_tstzspan_tstzspan(p1, p2); + }; + + // Per-type span distance (each returns the type's natural distance scalar) + public static final UDF2 intspanDistance = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.distance_intspan_intspan(p1, p2); + }; + public static final UDF2 bigintspanDistance = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.distance_bigintspan_bigintspan(p1, p2); + }; + public static final UDF2 floatspanDistance = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.distance_floatspan_floatspan(p1, p2); + }; + public static final UDF2 datespanDistance = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = spanPtr(s1), p2 = spanPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.distance_datespan_datespan(p1, p2); + }; + + // Span expand: span + delta → expanded span + public static final UDF2 intspanExpand = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(s); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.intspan_expand(p, v.intValue()); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(p); } + }; + public static final UDF2 bigintspanExpand = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(s); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.bigintspan_expand(p, v.longValue()); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(p); } + }; + public static final UDF2 floatspanExpand = + (s, v) -> { + if (s == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(s); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.floatspan_expand(p, v.doubleValue()); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { org.mobilitydb.spark.MeosMemory.free(r); } + } finally { org.mobilitydb.spark.MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Spanset topology predicates (spanset, span) → Boolean + // + // MEOS: contains_spanset_span / contained_spanset_span + // overlaps_spanset_spanset + // ------------------------------------------------------------------ + + // spansetContainsSpan("{[1,5),[7,10)}", "[2,4)") → true + public static final UDF2 spansetContainsSpan = + (ss, s) -> { + MeosThread.ensureReady(); + Pointer pss = spansetPtr(ss), ps = spanPtr(s); + if (pss == null || ps == null) return null; + return functions.contains_spanset_span(pss, ps); + }; + + // spanContainedInSpanset("[2,4)", "{[1,5),[7,10)}") → true + public static final UDF2 spanContainedInSpanset = + (s, ss) -> { + MeosThread.ensureReady(); + Pointer ps = spanPtr(s), pss = spansetPtr(ss); + if (ps == null || pss == null) return null; + return functions.contained_span_spanset(ps, pss); + }; + + // spansetOverlaps("{[1,5)}", "{[3,10)}") → true + public static final UDF2 spansetOverlaps = + (ss1, ss2) -> { + MeosThread.ensureReady(); + Pointer p1 = spansetPtr(ss1), p2 = spansetPtr(ss2); + if (p1 == null || p2 == null) return null; + return functions.overlaps_spanset_spanset(p1, p2); + }; + + // ------------------------------------------------------------------ + // Spanset algebraic operations (spanset, spanset) → hex-WKB STRING + // + // MEOS: union_spanset_spanset / intersection_spanset_spanset + // minus_spanset_spanset + // ------------------------------------------------------------------ + + // spansetUnion("{[1,5)}", "{[7,10)}") → "{[1,5),[7,10)}" + public static final UDF2 spansetUnion = + (ss1, ss2) -> { + MeosThread.ensureReady(); + Pointer p1 = spansetPtr(ss1), p2 = spansetPtr(ss2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.union_spanset_spanset(p1, p2); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // spansetIntersection("{[1,10)}", "{[3,7)}") → "{[3,7)}" + public static final UDF2 spansetIntersection = + (ss1, ss2) -> { + MeosThread.ensureReady(); + Pointer p1 = spansetPtr(ss1), p2 = spansetPtr(ss2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.intersection_spanset_spanset(p1, p2); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // spansetMinus("{[1,10)}", "{[3,7)}") → "{[1,3),[7,10)}" + public static final UDF2 spansetMinus = + (ss1, ss2) -> { + MeosThread.ensureReady(); + Pointer p1 = spansetPtr(ss1), p2 = spansetPtr(ss2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.minus_spanset_spanset(p1, p2); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Cross-type spanset × span algebra + // MEOS: intersection_spanset_span(SpanSet *, Span *) → SpanSet * + // union_spanset_span(SpanSet *, Span *) → SpanSet * + // minus_spanset_span(SpanSet *, Span *) → SpanSet * + // ------------------------------------------------------------------ + + // spansetIntersectionSpan("{[1,10)}", "[3,7)") → "{[3,7)}" + public static final UDF2 spansetIntersectionSpan = + (ss, s) -> { + MeosThread.ensureReady(); + Pointer pss = spansetPtr(ss), ps = spanPtr(s); + if (pss == null || ps == null) return null; + Pointer r = functions.intersection_spanset_span(pss, ps); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // spansetUnionSpan("{[1,5)}", "[7,10)") → "{[1,5),[7,10)}" + public static final UDF2 spansetUnionSpan = + (ss, s) -> { + MeosThread.ensureReady(); + Pointer pss = spansetPtr(ss), ps = spanPtr(s); + if (pss == null || ps == null) return null; + Pointer r = functions.union_spanset_span(pss, ps); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // spansetMinusSpan("{[1,10)}", "[3,7)") → "{[1,3),[7,10)}" + public static final UDF2 spansetMinusSpan = + (ss, s) -> { + MeosThread.ensureReady(); + Pointer pss = spansetPtr(ss), ps = spanPtr(s); + if (pss == null || ps == null) return null; + Pointer r = functions.minus_spanset_span(pss, ps); + if (r == null) return null; + return functions.spanset_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Set topology predicates (set, set) → Boolean + // + // MEOS: contains_set_set / overlaps_set_set + // ------------------------------------------------------------------ + + // setContains("{1,2,3,4}", "{2,3}") → true + public static final UDF2 setContains = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = setPtr(s1), p2 = setPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.contains_set_set(p1, p2); + }; + + // setOverlaps("{1,2,3}", "{3,4,5}") → true + public static final UDF2 setOverlaps = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = setPtr(s1), p2 = setPtr(s2); + if (p1 == null || p2 == null) return null; + return functions.overlaps_set_set(p1, p2); + }; + + // ------------------------------------------------------------------ + // Set algebraic operations (set, set) → hex-WKB STRING + // + // MEOS: union_set_set / intersection_set_set / minus_set_set → Set * + // ------------------------------------------------------------------ + + // setUnion("{1,2,3}", "{4,5}") → "{1,2,3,4,5}" + public static final UDF2 setUnion = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = setPtr(s1), p2 = setPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.union_set_set(p1, p2); + if (r == null) return null; + return functions.set_as_hexwkb(r, (byte) 0); + }; + + // setIntersection("{1,2,3,4}", "{3,4,5}") → "{3,4}" + public static final UDF2 setIntersection = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = setPtr(s1), p2 = setPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.intersection_set_set(p1, p2); + if (r == null) return null; + return functions.set_as_hexwkb(r, (byte) 0); + }; + + // setMinus("{1,2,3,4}", "{3,4,5}") → "{1,2}" + public static final UDF2 setMinus = + (s1, s2) -> { + MeosThread.ensureReady(); + Pointer p1 = setPtr(s1), p2 = setPtr(s2); + if (p1 == null || p2 == null) return null; + Pointer r = functions.minus_set_set(p1, p2); + if (r == null) return null; + return functions.set_as_hexwkb(r, (byte) 0); + }; + + // milliseconds from Unix epoch (1970-01-01) to PG epoch (2000-01-01) + private static final long PG_UNIX_OFFSET_MS = 946684800L * 1000L; + + // ------------------------------------------------------------------ + // Span type conversions + // + // MEOS: intspan_to_floatspan, floatspan_to_intspan, + // datespan_to_tstzspan, tstzspan_to_datespan + // ------------------------------------------------------------------ + + public static final UDF1 intspanToFloatspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer result = functions.intspan_to_floatspan(p); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 floatspanToIntspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer result = functions.floatspan_to_intspan(p); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 datespanToTstzspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer result = functions.datespan_to_tstzspan(p); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 tstzspanToDatespan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer result = functions.tstzspan_to_datespan(p); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + // ------------------------------------------------------------------ + // Set type conversions + // + // MEOS: intset_to_floatset, floatset_to_intset, + // set_to_span, set_to_spanset + // ------------------------------------------------------------------ + + public static final UDF1 intsetToFloatset = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + Pointer result = functions.intset_to_floatset(p); + if (result == null) return null; + try { return functions.set_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 floatsetToIntset = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + Pointer result = functions.floatset_to_intset(p); + if (result == null) return null; + try { return functions.set_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 setToSpan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + Pointer result = functions.set_to_span(p); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 setToSpanset = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + Pointer result = functions.set_to_spanset(p); + if (result == null) return null; + try { return functions.spanset_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + // ------------------------------------------------------------------ + // Span duration + // + // MEOS: tstzspan_duration, datespan_duration → Interval * + // Output: PG interval string via pg_interval_out (e.g. "2 days") + // ------------------------------------------------------------------ + + public static final UDF1 tstzspanDuration = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer iv = functions.tstzspan_duration(p); + if (iv == null) return null; + return functions.pg_interval_out(iv); + }; + + public static final UDF1 datespanDuration = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer iv = functions.datespan_duration(p); + if (iv == null) return null; + return functions.pg_interval_out(iv); + }; + + // ------------------------------------------------------------------ + // Span/spanset shift-and-scale + // + // MEOS: tstzspan_shift_scale, tstzspanset_shift_scale + // Either shift or scale interval may be null. + // ------------------------------------------------------------------ + + public static final UDF3 tstzspanShiftScale = + (hex, shiftStr, scaleStr) -> { + if (hex == null) return null; + if (shiftStr == null && scaleStr == null) return null; + MeosThread.ensureReady(); + Pointer p = spanPtr(hex); + if (p == null) return null; + Pointer shiftIv = shiftStr != null ? functions.pg_interval_in(shiftStr, -1) : null; + Pointer scaleIv = scaleStr != null ? functions.pg_interval_in(scaleStr, -1) : null; + Pointer result = functions.tstzspan_shift_scale(p, shiftIv, scaleIv); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { + MeosMemory.free(result); + if (shiftIv != null) MeosMemory.free(shiftIv); + if (scaleIv != null) MeosMemory.free(scaleIv); + } + }; + + public static final UDF3 tstzspansetShiftScale = + (hex, shiftStr, scaleStr) -> { + if (hex == null) return null; + if (shiftStr == null && scaleStr == null) return null; + MeosThread.ensureReady(); + Pointer p = spansetPtr(hex); + if (p == null) return null; + Pointer shiftIv = shiftStr != null ? functions.pg_interval_in(shiftStr, -1) : null; + Pointer scaleIv = scaleStr != null ? functions.pg_interval_in(scaleStr, -1) : null; + Pointer result = functions.tstzspanset_shift_scale(p, shiftIv, scaleIv); + if (result == null) return null; + try { return functions.spanset_as_hexwkb(result, (byte) 0); } + finally { + MeosMemory.free(result); + if (shiftIv != null) MeosMemory.free(shiftIv); + if (scaleIv != null) MeosMemory.free(scaleIv); + } + }; + + // ------------------------------------------------------------------ + // Timestamp → span/set singletons + // + // MEOS: timestamptz_to_span, timestamptz_to_set + // ------------------------------------------------------------------ + + public static final UDF1 timestamptzToSpan = + (ts) -> { + if (ts == null) return null; + MeosThread.ensureReady(); + long pgMicros = (ts.getTime() - PG_UNIX_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pgMicros, 0), ZoneOffset.UTC); + Pointer result = functions.timestamptz_to_span(odt); + if (result == null) return null; + try { return functions.span_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static final UDF1 timestamptzToSet = + (ts) -> { + if (ts == null) return null; + MeosThread.ensureReady(); + long pgMicros = (ts.getTime() - PG_UNIX_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pgMicros, 0), ZoneOffset.UTC); + Pointer result = functions.timestamptz_to_set(odt); + if (result == null) return null; + try { return functions.set_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + }; + + public static void registerAll(SparkSession spark) { + // Span topology predicates + spark.udf().register("spanContains", spanContains, DataTypes.BooleanType); + spark.udf().register("spanContainedIn", spanContainedIn, DataTypes.BooleanType); + spark.udf().register("spanOverlaps", spanOverlaps, DataTypes.BooleanType); + spark.udf().register("spanAdjacent", spanAdjacent, DataTypes.BooleanType); + spark.udf().register("spanLeft", spanLeft, DataTypes.BooleanType); + spark.udf().register("spanRight", spanRight, DataTypes.BooleanType); + spark.udf().register("spanOverleft", spanOverleft, DataTypes.BooleanType); + spark.udf().register("spanOverright", spanOverright, DataTypes.BooleanType); + // Span algebra + spark.udf().register("spanUnion", spanUnion, DataTypes.StringType); + spark.udf().register("spanIntersection", spanIntersection, DataTypes.StringType); + spark.udf().register("spanMinus", spanMinus, DataTypes.StringType); + spark.udf().register("tstzspanDistance", tstzspanDistance, DataTypes.DoubleType); + spark.udf().register("intspanDistance", intspanDistance, DataTypes.IntegerType); + spark.udf().register("bigintspanDistance", bigintspanDistance, DataTypes.LongType); + spark.udf().register("floatspanDistance", floatspanDistance, DataTypes.DoubleType); + spark.udf().register("datespanDistance", datespanDistance, DataTypes.IntegerType); + spark.udf().register("spanDistance", floatspanDistance, DataTypes.DoubleType); + spark.udf().register("timeDistance", tstzspanDistance, DataTypes.DoubleType); + spark.udf().register("intspanExpand", intspanExpand, DataTypes.StringType); + spark.udf().register("bigintspanExpand", bigintspanExpand, DataTypes.StringType); + spark.udf().register("floatspanExpand", floatspanExpand, DataTypes.StringType); + spark.udf().register("expand", floatspanExpand, DataTypes.StringType); + // Spanset predicates + spark.udf().register("spansetContainsSpan", spansetContainsSpan, DataTypes.BooleanType); + spark.udf().register("spanContainedInSpanset", spanContainedInSpanset, DataTypes.BooleanType); + spark.udf().register("spansetOverlaps", spansetOverlaps, DataTypes.BooleanType); + // Spanset algebra + spark.udf().register("spansetUnion", spansetUnion, DataTypes.StringType); + spark.udf().register("spansetIntersection", spansetIntersection, DataTypes.StringType); + spark.udf().register("spansetMinus", spansetMinus, DataTypes.StringType); + // Set predicates + spark.udf().register("setContains", setContains, DataTypes.BooleanType); + spark.udf().register("setOverlaps", setOverlaps, DataTypes.BooleanType); + // Set algebra + spark.udf().register("setUnion", setUnion, DataTypes.StringType); + spark.udf().register("setIntersection", setIntersection, DataTypes.StringType); + spark.udf().register("setMinus", setMinus, DataTypes.StringType); + // Span type conversions + spark.udf().register("intspanToFloatspan", intspanToFloatspan, DataTypes.StringType); + spark.udf().register("floatspanToIntspan", floatspanToIntspan, DataTypes.StringType); + spark.udf().register("datespanToTstzspan", datespanToTstzspan, DataTypes.StringType); + spark.udf().register("tstzspanToDatespan", tstzspanToDatespan, DataTypes.StringType); + // Set type conversions + spark.udf().register("intsetToFloatset", intsetToFloatset, DataTypes.StringType); + spark.udf().register("floatsetToIntset", floatsetToIntset, DataTypes.StringType); + spark.udf().register("setToSpan", setToSpan, DataTypes.StringType); + spark.udf().register("setToSpanset", setToSpanset, DataTypes.StringType); + // Span duration + spark.udf().register("tstzspanDuration", tstzspanDuration, DataTypes.StringType); + spark.udf().register("datespanDuration", datespanDuration, DataTypes.StringType); + // Span/spanset shift-scale + spark.udf().register("tstzspanShiftScale", tstzspanShiftScale, DataTypes.StringType); + spark.udf().register("tstzspansetShiftScale", tstzspansetShiftScale, DataTypes.StringType); + // Timestamp singletons + spark.udf().register("timestamptzToSpan", timestamptzToSpan, DataTypes.StringType); + spark.udf().register("timestamptzToSet", timestamptzToSet, DataTypes.StringType); + // Cross-type spanset × span algebra + spark.udf().register("spansetIntersectionSpan", spansetIntersectionSpan, DataTypes.StringType); + spark.udf().register("spansetUnionSpan", spansetUnionSpan, DataTypes.StringType); + spark.udf().register("spansetMinusSpan", spansetMinusSpan, DataTypes.StringType); + // Scalar singleton constructors + spark.udf().register("intToSpan", intToSpan, DataTypes.StringType); + spark.udf().register("intToSet", intToSet, DataTypes.StringType); + spark.udf().register("intToSpanset", intToSpanset, DataTypes.StringType); + spark.udf().register("floatToSpan", floatToSpan, DataTypes.StringType); + spark.udf().register("floatToSet", floatToSet, DataTypes.StringType); + spark.udf().register("floatToSpanset", floatToSpanset, DataTypes.StringType); + spark.udf().register("intToTbox", intToTbox, DataTypes.StringType); + spark.udf().register("floatToTbox", floatToTbox, DataTypes.StringType); + } + + // ------------------------------------------------------------------ + // Scalar singleton constructors + // MEOS: int_to_span/set/spanset(int) → Span/Set/SpanSet * + // float_to_span/set/spanset(double) → Span/Set/SpanSet * + // int_to_tbox(int) / float_to_tbox(double) → TBox * + // ------------------------------------------------------------------ + + public static final UDF1 intToSpan = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.int_to_span(v); + if (r == null) return null; + String h = functions.span_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 intToSet = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.int_to_set(v); + if (r == null) return null; + String h = functions.set_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 intToSpanset = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.int_to_spanset(v); + if (r == null) return null; + String h = functions.spanset_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 floatToSpan = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.float_to_span(v); + if (r == null) return null; + String h = functions.span_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 floatToSet = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.float_to_set(v); + if (r == null) return null; + String h = functions.set_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 floatToSpanset = + (v) -> { if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.float_to_spanset(v); + if (r == null) return null; + String h = functions.spanset_as_hexwkb(r, (byte) 0); + MeosMemory.free(r); return h; }; + + public static final UDF1 intToTbox = + (v) -> { + if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.int_to_tbox(v); + if (r == null) return null; + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + String h = functions.tbox_as_hexwkb(r, (byte) 0, + rt.getMemoryManager().allocateDirect(8)); + MeosMemory.free(r); return h; + }; + + public static final UDF1 floatToTbox = + (v) -> { + if (v == null) return null; MeosThread.ensureReady(); + Pointer r = functions.float_to_tbox(v); + if (r == null) return null; + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + String h = functions.tbox_as_hexwkb(r, (byte) 0, + rt.getMemoryManager().allocateDirect(8)); + MeosMemory.free(r); return h; + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SpanUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SpanUDFs.java new file mode 100644 index 00000000..aa0a5b95 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SpanUDFs.java @@ -0,0 +1,117 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +import java.util.HexFormat; + +/** + * Spark SQL UDFs for span and spanset TemporalParquet readers. + * + * Each xFromBinary UDF converts a Parquet BYTE_ARRAY column (written by + * MobilityDuck's asBinary()) to the internal hex-WKB string used throughout + * MobilitySpark. + * + * Implementation uses the type-agnostic span_from_hexwkb / spanset_from_hexwkb + * MEOS functions — the WKB type-code embedded in the byte stream identifies the + * concrete span type. Type-specific names exist for SQL discoverability and to + * match the MobilityDuck surface (tstzspanFromBinary, intspanFromBinary, ...). + * + * Write-back (span → Parquet BINARY) uses the existing TemporalUDFs.asBinary, + * which hex-decodes any hex-WKB string regardless of the underlying MEOS type. + * + * MEOS function authority: meos/include/meos.h + */ +public final class SpanUDFs { + + private SpanUDFs() {} + + // ------------------------------------------------------------------ + // Span fromBinary helpers + // + // MEOS: span_from_hexwkb(const char *) → Span * + // span_as_hexwkb(const Span *, uint8_t variant) → char * + // ------------------------------------------------------------------ + private static String spanFromBinaryImpl(byte[] bytes) throws Exception { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer ptr = functions.span_from_hexwkb(hex); + if (ptr == null) return null; + return functions.span_as_hexwkb(ptr, (byte) 0); + } + + // ------------------------------------------------------------------ + // Spanset fromBinary helpers + // + // MEOS: spanset_from_hexwkb(const char *) → SpanSet * + // spanset_as_hexwkb(const SpanSet *, uint8_t variant) → char * + // ------------------------------------------------------------------ + private static String spansetFromBinaryImpl(byte[] bytes) throws Exception { + if (bytes == null) return null; + MeosThread.ensureReady(); + String hex = HexFormat.of().formatHex(bytes).toUpperCase(); + Pointer ptr = functions.spanset_from_hexwkb(hex); + if (ptr == null) return null; + return functions.spanset_as_hexwkb(ptr, (byte) 0); + } + + // ------------------------------------------------------------------ + // Span fromBinary UDFs + // ------------------------------------------------------------------ + public static final UDF1 tstzspanFromBinary = SpanUDFs::spanFromBinaryImpl; + public static final UDF1 intspanFromBinary = SpanUDFs::spanFromBinaryImpl; + public static final UDF1 floatspanFromBinary = SpanUDFs::spanFromBinaryImpl; + public static final UDF1 bigintspanFromBinary = SpanUDFs::spanFromBinaryImpl; + public static final UDF1 datespanFromBinary = SpanUDFs::spanFromBinaryImpl; + + // ------------------------------------------------------------------ + // Spanset fromBinary UDFs + // ------------------------------------------------------------------ + public static final UDF1 tstzspansetFromBinary = SpanUDFs::spansetFromBinaryImpl; + public static final UDF1 intspansetFromBinary = SpanUDFs::spansetFromBinaryImpl; + public static final UDF1 floatspansetFromBinary = SpanUDFs::spansetFromBinaryImpl; + public static final UDF1 bigintspansetFromBinary = SpanUDFs::spansetFromBinaryImpl; + public static final UDF1 datespansetFromBinary = SpanUDFs::spansetFromBinaryImpl; + + public static void registerAll(org.apache.spark.sql.SparkSession spark) { + spark.udf().register("tstzspanFromBinary", tstzspanFromBinary, DataTypes.StringType); + spark.udf().register("intspanFromBinary", intspanFromBinary, DataTypes.StringType); + spark.udf().register("floatspanFromBinary", floatspanFromBinary, DataTypes.StringType); + spark.udf().register("bigintspanFromBinary", bigintspanFromBinary, DataTypes.StringType); + spark.udf().register("datespanFromBinary", datespanFromBinary, DataTypes.StringType); + spark.udf().register("tstzspansetFromBinary", tstzspansetFromBinary, DataTypes.StringType); + spark.udf().register("intspansetFromBinary", intspansetFromBinary, DataTypes.StringType); + spark.udf().register("floatspansetFromBinary", floatspansetFromBinary, DataTypes.StringType); + spark.udf().register("bigintspansetFromBinary", bigintspansetFromBinary, DataTypes.StringType); + spark.udf().register("datespansetFromBinary", datespansetFromBinary, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SpansetOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SpansetOpsUDFs.java new file mode 100644 index 00000000..7fd14773 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SpansetOpsUDFs.java @@ -0,0 +1,155 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for cross-type positional and topological predicates between + * Span and Spanset types. + * + * Coverage: span×spanset, spanset×span, spanset×spanset — 8 predicates each = 24 UDFs + * Predicates: left, right, overleft, overright, adjacent, contains, contained, overlaps + * + * MEOS function authority: meos/include/meos.h + */ +public final class SpansetOpsUDFs { + + private SpansetOpsUDFs() {} + + private static UDF2 spanSpanset(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.span_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.spanset_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 spansetSpan(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.spanset_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.span_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 spansetSpanset(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.spanset_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.spanset_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + // ------------------------------------------------------------------ + // span × spanset + // ------------------------------------------------------------------ + + public static final UDF2 spanLeftSpanset = spanSpanset(functions::left_span_spanset); + public static final UDF2 spanOverleftSpanset = spanSpanset(functions::overleft_span_spanset); + public static final UDF2 spanRightSpanset = spanSpanset(functions::right_span_spanset); + public static final UDF2 spanOverrightSpanset = spanSpanset(functions::overright_span_spanset); + public static final UDF2 spanAdjacentSpanset = spanSpanset(functions::adjacent_span_spanset); + public static final UDF2 spanContainsSpanset = spanSpanset(functions::contains_span_spanset); + public static final UDF2 spanContainedSpanset = spanSpanset(functions::contained_span_spanset); + public static final UDF2 spanOverlapsSpanset = spanSpanset(functions::overlaps_span_spanset); + + // ------------------------------------------------------------------ + // spanset × span + // ------------------------------------------------------------------ + + public static final UDF2 spansetLeftSpan = spansetSpan(functions::left_spanset_span); + public static final UDF2 spansetOverleftSpan = spansetSpan(functions::overleft_spanset_span); + public static final UDF2 spansetRightSpan = spansetSpan(functions::right_spanset_span); + public static final UDF2 spansetOverrightSpan = spansetSpan(functions::overright_spanset_span); + public static final UDF2 spansetAdjacentSpan = spansetSpan(functions::adjacent_spanset_span); + public static final UDF2 spansetContainedSpan = spansetSpan(functions::contained_spanset_span); + public static final UDF2 spansetOverlapsSpan = spansetSpan(functions::overlaps_spanset_span); + // spansetContainsSpan already registered by SpanAlgebraUDFs; omitted here to avoid redundant duplicate. + + // ------------------------------------------------------------------ + // spanset × spanset + // ------------------------------------------------------------------ + + public static final UDF2 spansetLeftSpanset = spansetSpanset(functions::left_spanset_spanset); + public static final UDF2 spansetOverleftSpanset = spansetSpanset(functions::overleft_spanset_spanset); + public static final UDF2 spansetRightSpanset = spansetSpanset(functions::right_spanset_spanset); + public static final UDF2 spansetOverrightSpanset = spansetSpanset(functions::overright_spanset_spanset); + public static final UDF2 spansetAdjacentSpanset = spansetSpanset(functions::adjacent_spanset_spanset); + public static final UDF2 spansetContainsSpanset = spansetSpanset(functions::contains_spanset_spanset); + public static final UDF2 spansetContainedSpanset = spansetSpanset(functions::contained_spanset_spanset); + // spansetOverlaps(spanset, spanset) already registered by SpanAlgebraUDFs. + + public static void registerAll(SparkSession spark) { + // span × spanset + spark.udf().register("spanLeftSpanset", spanLeftSpanset, DataTypes.BooleanType); + spark.udf().register("spanOverleftSpanset", spanOverleftSpanset, DataTypes.BooleanType); + spark.udf().register("spanRightSpanset", spanRightSpanset, DataTypes.BooleanType); + spark.udf().register("spanOverrightSpanset", spanOverrightSpanset, DataTypes.BooleanType); + spark.udf().register("spanAdjacentSpanset", spanAdjacentSpanset, DataTypes.BooleanType); + spark.udf().register("spanContainsSpanset", spanContainsSpanset, DataTypes.BooleanType); + spark.udf().register("spanContainedSpanset", spanContainedSpanset, DataTypes.BooleanType); + spark.udf().register("spanOverlapsSpanset", spanOverlapsSpanset, DataTypes.BooleanType); + + // spanset × span + spark.udf().register("spansetLeftSpan", spansetLeftSpan, DataTypes.BooleanType); + spark.udf().register("spansetOverleftSpan", spansetOverleftSpan, DataTypes.BooleanType); + spark.udf().register("spansetRightSpan", spansetRightSpan, DataTypes.BooleanType); + spark.udf().register("spansetOverrightSpan", spansetOverrightSpan, DataTypes.BooleanType); + spark.udf().register("spansetAdjacentSpan", spansetAdjacentSpan, DataTypes.BooleanType); + spark.udf().register("spansetContainedSpan", spansetContainedSpan, DataTypes.BooleanType); + spark.udf().register("spansetOverlapsSpan", spansetOverlapsSpan, DataTypes.BooleanType); + + // spanset × spanset + spark.udf().register("spansetLeftSpanset", spansetLeftSpanset, DataTypes.BooleanType); + spark.udf().register("spansetOverleftSpanset", spansetOverleftSpanset, DataTypes.BooleanType); + spark.udf().register("spansetRightSpanset", spansetRightSpanset, DataTypes.BooleanType); + spark.udf().register("spansetOverrightSpanset", spansetOverrightSpanset, DataTypes.BooleanType); + spark.udf().register("spansetAdjacentSpanset", spansetAdjacentSpanset, DataTypes.BooleanType); + spark.udf().register("spansetContainsSpanset", spansetContainsSpanset, DataTypes.BooleanType); + spark.udf().register("spansetContainedSpanset", spansetContainedSpanset, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/SubtypeConstructorUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/SubtypeConstructorUDFs.java new file mode 100644 index 00000000..ec35b98c --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/SubtypeConstructorUDFs.java @@ -0,0 +1,323 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.sql.Timestamp; +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for typed temporal-instant constructors and typed + * subtype-conversion aliases (tboolSeq → temporalToTsequence, etc.). + * + * MEOS function authority: meos/include/meos.h — *inst_make, + * temporal_to_tinstant/_to_tsequence/_to_tsequenceset. + */ +public final class SubtypeConstructorUDFs { + + private SubtypeConstructorUDFs() {} + + private static OffsetDateTime toOdt(Timestamp ts) { + return Instant.ofEpochMilli(ts.getTime()).atOffset(ZoneOffset.UTC); + } + + // ------------------------------------------------------------------ + // Per-type Inst constructors — (value, timestamp) → temporal instant + // ------------------------------------------------------------------ + + public static final UDF2 tboolInst = + (v, ts) -> { + if (v == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tboolinst_make(v, toOdt(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 tintInst = + (v, ts) -> { + if (v == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tintinst_make(v, toOdt(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + public static final UDF2 tfloatInst = + (v, ts) -> { + if (v == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.tfloatinst_make(v, toOdt(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + }; + + // tpointInst((point WKT), timestamp) — used for tgeompoint/tgeogpoint + public static final UDF2 tgeompointInst = + (geomWkt, ts) -> { + if (geomWkt == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) return null; + try { + Pointer p = functions.tpointinst_make(g, toOdt(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + } finally { MeosMemory.free(g); } + }; + + public static final UDF2 tgeogpointInst = tgeompointInst; + + // tgeometryInst((geometry WKT), timestamp) — for general geometry, not just points + public static final UDF2 tgeometryInst = + (geomWkt, ts) -> { + if (geomWkt == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer g = functions.geo_from_text(geomWkt, 0); + if (g == null) return null; + try { + Pointer p = org.mobilitydb.spark.MeosNative.INSTANCE + .tgeoinst_make(g, toPgEpochMicros(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + } finally { MeosMemory.free(g); } + }; + + public static final UDF2 tgeographyInst = tgeometryInst; + + public static final UDF2 ttextInst = + (v, ts) -> { + if (v == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer txt = functions.cstring2text(v); + if (txt == null) return null; + try { + Pointer p = functions.ttextinst_make(txt, toOdt(ts)); + if (p == null) return null; + try { return functions.temporal_as_hexwkb(p, (byte) 0); } + finally { MeosMemory.free(p); } + } finally { MeosMemory.free(txt); } + }; + + // ------------------------------------------------------------------ + // Typed Seq / SeqSet aliases — call the generic conversion with a + // default 'linear' interpolation. + // ------------------------------------------------------------------ + + private static UDF1 seqAlias() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.temporal_to_tsequence(p, "linear"); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + } + + private static UDF1 seqSetAlias() { + return hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.temporal_to_tsequenceset(p, "linear"); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + } + + public static final UDF1 tboolSeq = seqAlias(); + public static final UDF1 tintSeq = seqAlias(); + public static final UDF1 tfloatSeq = seqAlias(); + public static final UDF1 ttextSeq = seqAlias(); + public static final UDF1 tgeompointSeq = seqAlias(); + public static final UDF1 tgeogpointSeq = seqAlias(); + public static final UDF1 tgeometrySeq = seqAlias(); + public static final UDF1 tgeographySeq = seqAlias(); + + public static final UDF1 tboolSeqSet = seqSetAlias(); + public static final UDF1 tintSeqSet = seqSetAlias(); + public static final UDF1 tfloatSeqSet = seqSetAlias(); + public static final UDF1 ttextSeqSet = seqSetAlias(); + public static final UDF1 tgeompointSeqSet = seqSetAlias(); + public static final UDF1 tgeogpointSeqSet = seqSetAlias(); + public static final UDF1 tgeometrySeqSet = seqSetAlias(); + public static final UDF1 tgeographySeqSet = seqSetAlias(); + + // ------------------------------------------------------------------ + // Accessor aliases (MobilityDB SQL bare names) + // ------------------------------------------------------------------ + + // temporal subtype label (Inst | Seq | SeqSet) + public static final UDF1 tempSubtype = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return functions.temporal_subtype(p); } + finally { MeosMemory.free(p); } + }; + + // memory size of the serialised temporal value + public static final UDF1 memSize = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { return org.mobilitydb.spark.MeosNative.INSTANCE.temporal_mem_size(p); } + finally { MeosMemory.free(p); } + }; + + // getTime → temporal_time → SpanSet hex + public static final UDF1 getTime = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer ss = functions.temporal_time(p); + if (ss == null) return null; + try { return functions.spanset_as_hexwkb(ss, (byte) 0); } + finally { MeosMemory.free(ss); } + } finally { MeosMemory.free(p); } + }; + + // deleteTime(temporal, ts) → temporal with the timestamp removed (connect=true) + public static final UDF2 deleteTime = + (hex, ts) -> { + if (hex == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.temporal_delete_timestamptz(p, toOdt(ts), true); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + private static long toPgEpochMicros(Timestamp ts) { + return (ts.getTime() - 946684800L * 1000L) * 1000L; + } + + // beforeTimestamp(temporal, ts) → temporal restricted to before ts + public static final UDF2 beforeTimestamp = + (hex, ts) -> { + if (hex == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_before_timestamptz(p, toPgEpochMicros(ts)); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF2 afterTimestamp = + (hex, ts) -> { + if (hex == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE + .temporal_after_timestamptz(p, toPgEpochMicros(ts)); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static void registerAll(SparkSession spark) { + // Inst constructors + spark.udf().register("tboolInst", tboolInst, DataTypes.StringType); + spark.udf().register("tintInst", tintInst, DataTypes.StringType); + spark.udf().register("tfloatInst", tfloatInst, DataTypes.StringType); + spark.udf().register("ttextInst", ttextInst, DataTypes.StringType); + spark.udf().register("tgeompointInst", tgeompointInst, DataTypes.StringType); + spark.udf().register("tgeogpointInst", tgeogpointInst, DataTypes.StringType); + spark.udf().register("tgeometryInst", tgeometryInst, DataTypes.StringType); + spark.udf().register("tgeographyInst", tgeographyInst, DataTypes.StringType); + + // Seq aliases + spark.udf().register("tboolSeq", tboolSeq, DataTypes.StringType); + spark.udf().register("tintSeq", tintSeq, DataTypes.StringType); + spark.udf().register("tfloatSeq", tfloatSeq, DataTypes.StringType); + spark.udf().register("ttextSeq", ttextSeq, DataTypes.StringType); + spark.udf().register("tgeompointSeq", tgeompointSeq, DataTypes.StringType); + spark.udf().register("tgeogpointSeq", tgeogpointSeq, DataTypes.StringType); + spark.udf().register("tgeometrySeq", tgeometrySeq, DataTypes.StringType); + spark.udf().register("tgeographySeq", tgeographySeq, DataTypes.StringType); + + // SeqSet aliases + spark.udf().register("tboolSeqSet", tboolSeqSet, DataTypes.StringType); + spark.udf().register("tintSeqSet", tintSeqSet, DataTypes.StringType); + spark.udf().register("tfloatSeqSet", tfloatSeqSet, DataTypes.StringType); + spark.udf().register("ttextSeqSet", ttextSeqSet, DataTypes.StringType); + spark.udf().register("tgeompointSeqSet", tgeompointSeqSet, DataTypes.StringType); + spark.udf().register("tgeogpointSeqSet", tgeogpointSeqSet, DataTypes.StringType); + spark.udf().register("tgeometrySeqSet", tgeometrySeqSet, DataTypes.StringType); + spark.udf().register("tgeographySeqSet", tgeographySeqSet, DataTypes.StringType); + + // Accessor aliases + spark.udf().register("tempSubtype", tempSubtype, DataTypes.StringType); + spark.udf().register("memSize", memSize, DataTypes.IntegerType); + spark.udf().register("getTime", getTime, DataTypes.StringType); + spark.udf().register("deleteTime", deleteTime, DataTypes.StringType); + spark.udf().register("beforeTimestamp", beforeTimestamp, DataTypes.StringType); + spark.udf().register("afterTimestamp", afterTimestamp, DataTypes.StringType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TBoxOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TBoxOpsUDFs.java new file mode 100644 index 00000000..0ce73a06 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TBoxOpsUDFs.java @@ -0,0 +1,193 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for cross-type positional, temporal, and topological + * predicates between TBox and TNumber types. + * + * Coverage: tbox×tbox, tbox×tnumber, tnumber×tbox — 13 predicates each = 39 UDFs + * Predicates: left, right, overleft, overright (X axis); + * before, after, overbefore, overafter (time axis); + * adjacent, contains, contained, overlaps, same (topological) + * + * MEOS function authority: meos/include/meos.h + */ +public final class TBoxOpsUDFs { + + private TBoxOpsUDFs() {} + + // ------------------------------------------------------------------ + // Helpers — reduce 39× boilerplate to one factory per cross-type + // ------------------------------------------------------------------ + + private static UDF2 tboxTbox(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.tbox_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.tbox_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 tboxTnumber(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.tbox_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 tnumberTbox(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.tbox_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + // ------------------------------------------------------------------ + // tbox × tbox + // ------------------------------------------------------------------ + + public static final UDF2 tboxLeftTbox = tboxTbox(functions::left_tbox_tbox); + public static final UDF2 tboxOverleftTbox = tboxTbox(functions::overleft_tbox_tbox); + public static final UDF2 tboxRightTbox = tboxTbox(functions::right_tbox_tbox); + public static final UDF2 tboxOverrightTbox = tboxTbox(functions::overright_tbox_tbox); + public static final UDF2 tboxBeforeTbox = tboxTbox(functions::before_tbox_tbox); + public static final UDF2 tboxOverbeforeTbox = tboxTbox(functions::overbefore_tbox_tbox); + public static final UDF2 tboxAfterTbox = tboxTbox(functions::after_tbox_tbox); + public static final UDF2 tboxOverafterTbox = tboxTbox(functions::overafter_tbox_tbox); + public static final UDF2 tboxAdjacentTbox = tboxTbox(functions::adjacent_tbox_tbox); + public static final UDF2 tboxContainsTbox = tboxTbox(functions::contains_tbox_tbox); + public static final UDF2 tboxContainedTbox = tboxTbox(functions::contained_tbox_tbox); + public static final UDF2 tboxOverlapsTbox = tboxTbox(functions::overlaps_tbox_tbox); + public static final UDF2 tboxSameTbox = tboxTbox(functions::same_tbox_tbox); + + // ------------------------------------------------------------------ + // tbox × tnumber + // ------------------------------------------------------------------ + + public static final UDF2 tboxLeftTnumber = tboxTnumber(functions::left_tbox_tnumber); + public static final UDF2 tboxOverleftTnumber = tboxTnumber(functions::overleft_tbox_tnumber); + public static final UDF2 tboxRightTnumber = tboxTnumber(functions::right_tbox_tnumber); + public static final UDF2 tboxOverrightTnumber = tboxTnumber(functions::overright_tbox_tnumber); + public static final UDF2 tboxBeforeTnumber = tboxTnumber(functions::before_tbox_tnumber); + public static final UDF2 tboxOverbeforeTnumber = tboxTnumber(functions::overbefore_tbox_tnumber); + public static final UDF2 tboxAfterTnumber = tboxTnumber(functions::after_tbox_tnumber); + public static final UDF2 tboxOverafterTnumber = tboxTnumber(functions::overafter_tbox_tnumber); + public static final UDF2 tboxAdjacentTnumber = tboxTnumber(functions::adjacent_tbox_tnumber); + public static final UDF2 tboxContainsTnumber = tboxTnumber(functions::contains_tbox_tnumber); + public static final UDF2 tboxContainedTnumber = tboxTnumber(functions::contained_tbox_tnumber); + public static final UDF2 tboxOverlapsTnumber = tboxTnumber(functions::overlaps_tbox_tnumber); + public static final UDF2 tboxSameTnumber = tboxTnumber(functions::same_tbox_tnumber); + + // ------------------------------------------------------------------ + // tnumber × tbox + // ------------------------------------------------------------------ + + public static final UDF2 tnumberLeftTbox = tnumberTbox(functions::left_tnumber_tbox); + public static final UDF2 tnumberOverleftTbox = tnumberTbox(functions::overleft_tnumber_tbox); + public static final UDF2 tnumberRightTbox = tnumberTbox(functions::right_tnumber_tbox); + public static final UDF2 tnumberOverrightTbox = tnumberTbox(functions::overright_tnumber_tbox); + public static final UDF2 tnumberBeforeTbox = tnumberTbox(functions::before_tnumber_tbox); + public static final UDF2 tnumberOverbeforeTbox = tnumberTbox(functions::overbefore_tnumber_tbox); + public static final UDF2 tnumberAfterTbox = tnumberTbox(functions::after_tnumber_tbox); + public static final UDF2 tnumberOverafterTbox = tnumberTbox(functions::overafter_tnumber_tbox); + public static final UDF2 tnumberAdjacentTbox = tnumberTbox(functions::adjacent_tnumber_tbox); + public static final UDF2 tnumberContainsTbox = tnumberTbox(functions::contains_tnumber_tbox); + public static final UDF2 tnumberContainedTbox = tnumberTbox(functions::contained_tnumber_tbox); + public static final UDF2 tnumberOverlapsTbox = tnumberTbox(functions::overlaps_tnumber_tbox); + public static final UDF2 tnumberSameTbox = tnumberTbox(functions::same_tnumber_tbox); + + public static void registerAll(SparkSession spark) { + // tbox × tbox + spark.udf().register("tboxLeftTbox", tboxLeftTbox, DataTypes.BooleanType); + spark.udf().register("tboxOverleftTbox", tboxOverleftTbox, DataTypes.BooleanType); + spark.udf().register("tboxRightTbox", tboxRightTbox, DataTypes.BooleanType); + spark.udf().register("tboxOverrightTbox", tboxOverrightTbox, DataTypes.BooleanType); + spark.udf().register("tboxBeforeTbox", tboxBeforeTbox, DataTypes.BooleanType); + spark.udf().register("tboxOverbeforeTbox", tboxOverbeforeTbox, DataTypes.BooleanType); + spark.udf().register("tboxAfterTbox", tboxAfterTbox, DataTypes.BooleanType); + spark.udf().register("tboxOverafterTbox", tboxOverafterTbox, DataTypes.BooleanType); + spark.udf().register("tboxAdjacentTbox", tboxAdjacentTbox, DataTypes.BooleanType); + spark.udf().register("tboxContainsTbox", tboxContainsTbox, DataTypes.BooleanType); + spark.udf().register("tboxContainedTbox", tboxContainedTbox, DataTypes.BooleanType); + spark.udf().register("tboxOverlapsTbox", tboxOverlapsTbox, DataTypes.BooleanType); + spark.udf().register("tboxSameTbox", tboxSameTbox, DataTypes.BooleanType); + + // tbox × tnumber + spark.udf().register("tboxLeftTnumber", tboxLeftTnumber, DataTypes.BooleanType); + spark.udf().register("tboxOverleftTnumber", tboxOverleftTnumber, DataTypes.BooleanType); + spark.udf().register("tboxRightTnumber", tboxRightTnumber, DataTypes.BooleanType); + spark.udf().register("tboxOverrightTnumber", tboxOverrightTnumber, DataTypes.BooleanType); + spark.udf().register("tboxBeforeTnumber", tboxBeforeTnumber, DataTypes.BooleanType); + spark.udf().register("tboxOverbeforeTnumber", tboxOverbeforeTnumber, DataTypes.BooleanType); + spark.udf().register("tboxAfterTnumber", tboxAfterTnumber, DataTypes.BooleanType); + spark.udf().register("tboxOverafterTnumber", tboxOverafterTnumber, DataTypes.BooleanType); + spark.udf().register("tboxAdjacentTnumber", tboxAdjacentTnumber, DataTypes.BooleanType); + spark.udf().register("tboxContainsTnumber", tboxContainsTnumber, DataTypes.BooleanType); + spark.udf().register("tboxContainedTnumber", tboxContainedTnumber, DataTypes.BooleanType); + spark.udf().register("tboxOverlapsTnumber", tboxOverlapsTnumber, DataTypes.BooleanType); + spark.udf().register("tboxSameTnumber", tboxSameTnumber, DataTypes.BooleanType); + + // tnumber × tbox + spark.udf().register("tnumberLeftTbox", tnumberLeftTbox, DataTypes.BooleanType); + spark.udf().register("tnumberOverleftTbox", tnumberOverleftTbox, DataTypes.BooleanType); + spark.udf().register("tnumberRightTbox", tnumberRightTbox, DataTypes.BooleanType); + spark.udf().register("tnumberOverrightTbox", tnumberOverrightTbox, DataTypes.BooleanType); + spark.udf().register("tnumberBeforeTbox", tnumberBeforeTbox, DataTypes.BooleanType); + spark.udf().register("tnumberOverbeforeTbox", tnumberOverbeforeTbox, DataTypes.BooleanType); + spark.udf().register("tnumberAfterTbox", tnumberAfterTbox, DataTypes.BooleanType); + spark.udf().register("tnumberOverafterTbox", tnumberOverafterTbox, DataTypes.BooleanType); + spark.udf().register("tnumberAdjacentTbox", tnumberAdjacentTbox, DataTypes.BooleanType); + spark.udf().register("tnumberContainsTbox", tnumberContainsTbox, DataTypes.BooleanType); + spark.udf().register("tnumberContainedTbox", tnumberContainedTbox, DataTypes.BooleanType); + spark.udf().register("tnumberOverlapsTbox", tnumberOverlapsTbox, DataTypes.BooleanType); + spark.udf().register("tnumberSameTbox", tnumberSameTbox, DataTypes.BooleanType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TBoxUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TBoxUDFs.java new file mode 100644 index 00000000..9b8285f5 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TBoxUDFs.java @@ -0,0 +1,632 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for TBox (temporal numeric bounding box) accessor operations. + * + * TBox values are stored as hex-WKB strings (tbox_as_hexwkb output). + * + * Numeric bound accessors (xmin/xmax) use output-pointer pattern: JMEOS + * allocates an 8-byte buffer, passes it as out-pointer, returns null if + * the box has no X component. + * + * Temporal bound accessors (tmin/tmax) use the same pattern with int64 + * PG-epoch microseconds. Inclusivity accessors use a 1-byte output buffer. + * + * MEOS function authority: meos/include/meos.h + */ +public final class TBoxUDFs { + + private TBoxUDFs() {} + + // milliseconds from Unix epoch (1970-01-01) to PG epoch (2000-01-01) + private static final long PG_UNIX_OFFSET_MS = 946684800L * 1000L; + + private static Pointer tboxPtr(String hex) { + if (hex == null) return null; + return functions.tbox_from_hexwkb(hex); + } + + // ------------------------------------------------------------------ + // Has-component flags + // ------------------------------------------------------------------ + + public static final UDF1 tboxHasx = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + return functions.tbox_hasx(p); + }; + + public static final UDF1 tboxHast = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + return functions.tbox_hast(p); + }; + + // ------------------------------------------------------------------ + // Numeric (X) bound accessors (Pointer → double at offset 0) + // ------------------------------------------------------------------ + + public static final UDF1 tboxXmin = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_xmin(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 tboxXmax = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_xmax(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 tboxXminInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_xmin_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + public static final UDF1 tboxXmaxInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_xmax_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + // ------------------------------------------------------------------ + // Temporal (T) bound accessors (Pointer → int64 PG-epoch μs at offset 0) + // ------------------------------------------------------------------ + + public static final UDF1 tboxTmin = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_tmin(p); + if (r == null) return null; + return new java.sql.Timestamp(r.getLong(0) / 1000L + PG_UNIX_OFFSET_MS); + }; + + public static final UDF1 tboxTmax = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_tmax(p); + if (r == null) return null; + return new java.sql.Timestamp(r.getLong(0) / 1000L + PG_UNIX_OFFSET_MS); + }; + + public static final UDF1 tboxTminInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_tmin_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + public static final UDF1 tboxTmaxInc = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tbox_tmax_inc(p); + return r == null ? null : r.getByte(0) != 0; + }; + + // ------------------------------------------------------------------ + // Span conversions (tbox_hex → span hex-WKB) + // ------------------------------------------------------------------ + + public static final UDF1 tboxToIntspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer span = functions.tbox_to_intspan(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + public static final UDF1 tboxToFloatspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer span = functions.tbox_to_floatspan(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + public static final UDF1 tboxToTstzspan = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer span = functions.tbox_to_tstzspan(p); + if (span == null) return null; + return functions.span_as_hexwkb(span, (byte) 0); + }; + + // ------------------------------------------------------------------ + // Conversion from span / spanset / set to TBox + // ------------------------------------------------------------------ + + // spanToTbox(spanHex STRING) → STRING + // MEOS: span_to_tbox(const Span *) → TBox * + public static final UDF1 spanToTbox = + (spanHex) -> { + if (spanHex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(spanHex); + if (p == null) return null; + Pointer tb = functions.span_to_tbox(p); + if (tb == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + return functions.tbox_as_hexwkb(tb, (byte) 0, rt.getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(tb); + } + }; + + // spansetToTbox(spansetHex STRING) → STRING + // MEOS: spanset_to_tbox(const SpanSet *) → TBox * + public static final UDF1 spansetToTbox = + (spansetHex) -> { + if (spansetHex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(spansetHex); + if (p == null) return null; + Pointer tb = functions.spanset_to_tbox(p); + if (tb == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + return functions.tbox_as_hexwkb(tb, (byte) 0, rt.getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(tb); + } + }; + + // setToTbox(setHex STRING) → STRING + // MEOS: set_to_tbox(const Set *) → TBox * + public static final UDF1 setToTbox = + (setHex) -> { + if (setHex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(setHex); + if (p == null) return null; + Pointer tb = functions.set_to_tbox(p); + if (tb == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + return functions.tbox_as_hexwkb(tb, (byte) 0, rt.getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(tb); + } + }; + + // ------------------------------------------------------------------ + // Typed X-bound accessors (tboxfloat / tboxint variants) + // + // These differ from the generic tboxXmin/tboxXmax above in that they + // return integer values for tboxint and preserve float precision for + // tboxfloat — using the typed MEOS accessors rather than the generic ones. + // + // MEOS: tboxfloat_xmin, tboxfloat_xmax → double * + // tboxint_xmin, tboxint_xmax → int * (MEOS uses int32) + // ------------------------------------------------------------------ + + public static final UDF1 tboxfloatXmin = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tboxfloat_xmin(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 tboxfloatXmax = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tboxfloat_xmax(p); + return r == null ? null : r.getDouble(0); + }; + + public static final UDF1 tboxintXmin = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tboxint_xmin(p); + return r == null ? null : r.getInt(0); + }; + + public static final UDF1 tboxintXmax = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer r = functions.tboxint_xmax(p); + return r == null ? null : r.getInt(0); + }; + + // ------------------------------------------------------------------ + // TBox constructors (make, from numspan+timestamptz, from timestamptz) + // + // MEOS: tbox_make, numspan_timestamptz_to_tbox, timestamptz_to_tbox + // ------------------------------------------------------------------ + + // tboxMake(numspanHex STRING, tstzspanHex STRING) → STRING + // Either argument may be null to produce an X-only or T-only TBox. + public static final UDF2 tboxMake = + (numspanHex, tstzspanHex) -> { + if (numspanHex == null && tstzspanHex == null) return null; + MeosThread.ensureReady(); + Pointer numspan = numspanHex != null ? functions.span_from_hexwkb(numspanHex) : null; + Pointer tstzspan = tstzspanHex != null ? functions.span_from_hexwkb(tstzspanHex) : null; + Pointer result = functions.tbox_make(numspan, tstzspan); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // timestamptzToTbox(ts TIMESTAMP) → STRING + // MEOS: timestamptz_to_tbox(TimestampTz) → TBox * + public static final UDF1 timestamptzToTbox = + (ts) -> { + if (ts == null) return null; + MeosThread.ensureReady(); + long pgMicros = (ts.getTime() - PG_UNIX_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pgMicros, 0), ZoneOffset.UTC); + Pointer result = functions.timestamptz_to_tbox(odt); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // numspanTimestamptzToTbox(spanHex STRING, ts TIMESTAMP) → STRING + // MEOS: numspan_timestamptz_to_tbox(const Span *, TimestampTz) → TBox * + public static final UDF2 numspanTimestamptzToTbox = + (spanHex, ts) -> { + if (spanHex == null || ts == null) return null; + MeosThread.ensureReady(); + Pointer span = functions.span_from_hexwkb(spanHex); + if (span == null) return null; + long pgMicros = (ts.getTime() - PG_UNIX_OFFSET_MS) * 1000L; + OffsetDateTime odt = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pgMicros, 0), ZoneOffset.UTC); + Pointer result = functions.numspan_timestamptz_to_tbox(span, odt); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // TBox time-dimension transforms + // + // MEOS: tbox_expand_time, tbox_shift_scale_time + // ------------------------------------------------------------------ + + // tboxExpandTime(hex STRING, intervalStr STRING) → STRING + public static final UDF2 tboxExpandTime = + (hex, intervalStr) -> { + if (hex == null || intervalStr == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + Pointer result = functions.tbox_expand_time(p, iv); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // tboxExpandFloat(hex STRING, value DOUBLE) → STRING + // MEOS: tfloatbox_expand (renamed; not in JMEOS-1.4) + public static final UDF2 tboxExpandFloat = + (hex, v) -> { + if (hex == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer result = org.mobilitydb.spark.MeosNative.INSTANCE.tfloatbox_expand(p, v); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // tboxExpandInt(hex STRING, value INT) → STRING + // MEOS: tintbox_expand (renamed; not in JMEOS-1.4) + public static final UDF2 tboxExpandInt = + (hex, v) -> { + if (hex == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer result = org.mobilitydb.spark.MeosNative.INSTANCE.tintbox_expand(p, v); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // tboxShiftScaleTime(hex STRING, shiftStr STRING, scaleStr STRING) → STRING + // Either shiftStr or scaleStr (but not both) may be null. + public static final UDF3 tboxShiftScaleTime = + (hex, shiftStr, scaleStr) -> { + if (hex == null) return null; + if (shiftStr == null && scaleStr == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer shiftIv = shiftStr != null ? functions.pg_interval_in(shiftStr, -1) : null; + Pointer scaleIv = scaleStr != null ? functions.pg_interval_in(scaleStr, -1) : null; + Pointer result = functions.tbox_shift_scale_time(p, shiftIv, scaleIv); + if (result == null) return null; + try { + return functions.tbox_as_hexwkb(result, (byte) 0, + Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8)); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // Rounding + // ------------------------------------------------------------------ + + // tboxRound(hex STRING, maxDecimals INT) → STRING + // MEOS: tbox_round(const TBox *, int) → TBox * + public static final UDF2 tboxRound = + (hex, maxDecimals) -> { + if (hex == null || maxDecimals == null) return null; + MeosThread.ensureReady(); + Pointer p = tboxPtr(hex); + if (p == null) return null; + Pointer result = functions.tbox_round(p, maxDecimals); + if (result == null) return null; + try { + jnr.ffi.Runtime rt = jnr.ffi.Runtime.getSystemRuntime(); + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(result, (byte) 0, sizeOut); + } finally { + MeosMemory.free(result); + } + }; + + // ------------------------------------------------------------------ + // Registration + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + spark.udf().register("tboxHasx", tboxHasx, DataTypes.BooleanType); + spark.udf().register("tboxHast", tboxHast, DataTypes.BooleanType); + spark.udf().register("tboxXmin", tboxXmin, DataTypes.DoubleType); + spark.udf().register("tboxXmax", tboxXmax, DataTypes.DoubleType); + spark.udf().register("tboxXminInc", tboxXminInc, DataTypes.BooleanType); + spark.udf().register("tboxXmaxInc", tboxXmaxInc, DataTypes.BooleanType); + spark.udf().register("tboxTmin", tboxTmin, DataTypes.TimestampType); + spark.udf().register("tboxTmax", tboxTmax, DataTypes.TimestampType); + spark.udf().register("tboxTminInc", tboxTminInc, DataTypes.BooleanType); + spark.udf().register("tboxTmaxInc", tboxTmaxInc, DataTypes.BooleanType); + spark.udf().register("tboxToIntspan", tboxToIntspan, DataTypes.StringType); + spark.udf().register("tboxToFloatspan", tboxToFloatspan, DataTypes.StringType); + spark.udf().register("tboxToTstzspan", tboxToTstzspan, DataTypes.StringType); + spark.udf().register("tboxRound", tboxRound, DataTypes.StringType); + // Conversion from span / spanset / set to TBox + spark.udf().register("spanToTbox", spanToTbox, DataTypes.StringType); + spark.udf().register("spansetToTbox", spansetToTbox, DataTypes.StringType); + spark.udf().register("setToTbox", setToTbox, DataTypes.StringType); + // Typed X-bound accessors + spark.udf().register("tboxfloatXmin", tboxfloatXmin, DataTypes.DoubleType); + spark.udf().register("tboxfloatXmax", tboxfloatXmax, DataTypes.DoubleType); + spark.udf().register("tboxintXmin", tboxintXmin, DataTypes.IntegerType); + spark.udf().register("tboxintXmax", tboxintXmax, DataTypes.IntegerType); + // TBox constructors + spark.udf().register("tboxMake", tboxMake, DataTypes.StringType); + spark.udf().register("timestamptzToTbox", timestamptzToTbox, DataTypes.StringType); + spark.udf().register("numspanTimestamptzToTbox", numspanTimestamptzToTbox, DataTypes.StringType); + // TBox time-dimension transforms + spark.udf().register("tboxExpandTime", tboxExpandTime, DataTypes.StringType); + spark.udf().register("tboxExpandFloat", tboxExpandFloat, DataTypes.StringType); + spark.udf().register("tboxExpandInt", tboxExpandInt, DataTypes.StringType); + spark.udf().register("tboxShiftScaleTime", tboxShiftScaleTime, DataTypes.StringType); + // TBox set operations + spark.udf().register("intersectionTboxTbox", intersectionTboxTbox, DataTypes.StringType); + spark.udf().register("unionTboxTbox", unionTboxTbox, DataTypes.StringType); + // MobilityDB SQL bare-name aliases for the same lambdas + spark.udf().register("tboxIntersection", intersectionTboxTbox, DataTypes.StringType); + spark.udf().register("tboxUnion", unionTboxTbox, DataTypes.StringType); + // expandValue alias — covers float/int dispatch via Object input; + // most users will use the typed tboxExpandFloat/tboxExpandInt directly. + spark.udf().register("expandValue", tboxExpandFloat, DataTypes.StringType); + // TBox topology predicates (tbox, tbox) + spark.udf().register("tboxContains", tboxContains, DataTypes.BooleanType); + spark.udf().register("tboxContained", tboxContained, DataTypes.BooleanType); + spark.udf().register("tboxOverlaps", tboxOverlaps, DataTypes.BooleanType); + // TBox positional predicates (tbox, tbox) + spark.udf().register("tboxLeft", tboxLeft, DataTypes.BooleanType); + spark.udf().register("tboxOverleft", tboxOverleft, DataTypes.BooleanType); + spark.udf().register("tboxRight", tboxRight, DataTypes.BooleanType); + spark.udf().register("tboxOverright", tboxOverright, DataTypes.BooleanType); + spark.udf().register("tboxBefore", tboxBefore, DataTypes.BooleanType); + spark.udf().register("tboxOverbefore", tboxOverbefore, DataTypes.BooleanType); + spark.udf().register("tboxAfter", tboxAfter, DataTypes.BooleanType); + spark.udf().register("tboxOverafter", tboxOverafter, DataTypes.BooleanType); + spark.udf().register("tboxAdjacent", tboxAdjacent, DataTypes.BooleanType); + } + + // ------------------------------------------------------------------ + // TBox set operations + // MEOS: intersection_tbox_tbox(TBox *, TBox *) → TBox * (NULL if empty) + // union_tbox_tbox(TBox *, TBox *, bool strict) → TBox * + // ------------------------------------------------------------------ + + private static String tboxBinOp(String h1, String h2, + java.util.function.BiFunction fn) { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tboxPtr(h1), p2 = tboxPtr(h2); + if (p1 == null || p2 == null) return null; + Runtime rt = Runtime.getSystemRuntime(); + try { + Pointer r = fn.apply(p1, p2); + if (r == null) return null; + try { + return functions.tbox_as_hexwkb(r, (byte) 0, rt.getMemoryManager().allocateDirect(8)); + } finally { MeosMemory.free(r); } + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + } + + public static final UDF2 intersectionTboxTbox = + (h1, h2) -> tboxBinOp(h1, h2, functions::intersection_tbox_tbox); + + public static final UDF2 unionTboxTbox = + (h1, h2) -> tboxBinOp(h1, h2, (p1, p2) -> functions.union_tbox_tbox(p1, p2, false)); + + // ------------------------------------------------------------------ + // TBox positional predicates (tbox, tbox) → Boolean + // MEOS: left/overleft/right/overright/before/overbefore/after/overafter/adjacent + // _tbox_tbox(TBox *, TBox *) → bool + // ------------------------------------------------------------------ + + private static Boolean tboxBoolOp(String h1, String h2, + java.util.function.BiFunction fn) { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tboxPtr(h1), p2 = tboxPtr(h2); + if (p1 == null || p2 == null) return null; + return fn.apply(p1, p2); + } + + // ------------------------------------------------------------------ + // TBox topology predicates (tbox, tbox) → Boolean + // MEOS: contains/contained/overlaps_tbox_tbox → bool + // ------------------------------------------------------------------ + + public static final UDF2 tboxContains = + (h1, h2) -> tboxBoolOp(h1, h2, functions::contains_tbox_tbox); + public static final UDF2 tboxContained = + (h1, h2) -> tboxBoolOp(h1, h2, functions::contained_tbox_tbox); + public static final UDF2 tboxOverlaps = + (h1, h2) -> tboxBoolOp(h1, h2, functions::overlaps_tbox_tbox); + + public static final UDF2 tboxLeft = + (h1, h2) -> tboxBoolOp(h1, h2, functions::left_tbox_tbox); + public static final UDF2 tboxOverleft = + (h1, h2) -> tboxBoolOp(h1, h2, functions::overleft_tbox_tbox); + public static final UDF2 tboxRight = + (h1, h2) -> tboxBoolOp(h1, h2, functions::right_tbox_tbox); + public static final UDF2 tboxOverright = + (h1, h2) -> tboxBoolOp(h1, h2, functions::overright_tbox_tbox); + public static final UDF2 tboxBefore = + (h1, h2) -> tboxBoolOp(h1, h2, functions::before_tbox_tbox); + public static final UDF2 tboxOverbefore = + (h1, h2) -> tboxBoolOp(h1, h2, functions::overbefore_tbox_tbox); + public static final UDF2 tboxAfter = + (h1, h2) -> tboxBoolOp(h1, h2, functions::after_tbox_tbox); + public static final UDF2 tboxOverafter = + (h1, h2) -> tboxBoolOp(h1, h2, functions::overafter_tbox_tbox); + public static final UDF2 tboxAdjacent = + (h1, h2) -> tboxBoolOp(h1, h2, functions::adjacent_tbox_tbox); +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TTextUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TTextUDFs.java new file mode 100644 index 00000000..d3ac73a3 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TTextUDFs.java @@ -0,0 +1,280 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +/** + * Spark SQL UDFs for ttext case-conversion operations. + * + * MEOS function authority: meos/include/meos.h + */ +public final class TTextUDFs { + + private TTextUDFs() {} + + // ttext_upper(ttext hex-WKB) → ttext hex-WKB + public static final UDF1 ttextUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + Pointer r = functions.ttext_upper(p); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ttext_lower(ttext hex-WKB) → ttext hex-WKB + public static final UDF1 ttextLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + Pointer r = functions.ttext_lower(p); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ttext_initcap(ttext hex-WKB) → ttext hex-WKB + public static final UDF1 ttextInitcap = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + Pointer r = functions.ttext_initcap(p); + if (r == null) return null; + return functions.temporal_as_hexwkb(r, (byte) 0); + }; + + // ------------------------------------------------------------------ + // ttext comparison operators (scalar text vs ttext) + // + // MEOS: teq/tne/tlt/tle/tgt/tge_text_ttext(text *, Temporal *) → Temporal * + // teq/tne/tlt/tle/tgt/tge_ttext_text(Temporal *, text *) → Temporal * + // + // text * is created from a String via a dummy single-instant ttext and + // ttext_value_n, since text_in is not exposed by JMEOS-1.4. + // + // Both operators return a tbool hex-WKB (temporal boolean). + // ------------------------------------------------------------------ + + // Helper: allocate a MEOS text* from a Java String. + // Returns {textPtr, dummyTtext}; caller must MeosMemory.free() both. + private static Pointer[] makeTextPtr(String val) { + Pointer dummy = functions.ttext_in(val + "@2000-01-01 00:00:00+00"); + if (dummy == null) return null; + Pointer textPtr = functions.ttext_value_n(dummy, 1); + if (textPtr == null) { MeosMemory.free(dummy); return null; } + return new Pointer[]{textPtr, dummy}; + } + + private static String ttextCompare(String textVal, String ttextHex, java.util.function.BiFunction fn) { + if (textVal == null || ttextHex == null) return null; + MeosThread.ensureReady(); + Pointer[] tp = makeTextPtr(textVal); + if (tp == null) return null; + Pointer tptr = functions.temporal_from_hexwkb(ttextHex); + if (tptr == null) { MeosMemory.free(tp[0]); MeosMemory.free(tp[1]); return null; } + try { + Pointer result = fn.apply(tp[0], tptr); + if (result == null) return null; + try { return functions.temporal_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + } finally { + MeosMemory.free(tptr); + MeosMemory.free(tp[0]); + MeosMemory.free(tp[1]); + } + } + + private static String ttextCompareRev(String ttextHex, String textVal, java.util.function.BiFunction fn) { + if (ttextHex == null || textVal == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(ttextHex); + if (tptr == null) return null; + Pointer[] tp = makeTextPtr(textVal); + if (tp == null) { MeosMemory.free(tptr); return null; } + try { + Pointer result = fn.apply(tptr, tp[0]); + if (result == null) return null; + try { return functions.temporal_as_hexwkb(result, (byte) 0); } + finally { MeosMemory.free(result); } + } finally { + MeosMemory.free(tptr); + MeosMemory.free(tp[0]); + MeosMemory.free(tp[1]); + } + } + + // text op ttext + public static final UDF2 teqTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::teq_text_ttext); + public static final UDF2 tneTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::tne_text_ttext); + public static final UDF2 tltTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::tlt_text_ttext); + public static final UDF2 tleTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::tle_text_ttext); + public static final UDF2 tgtTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::tgt_text_ttext); + public static final UDF2 tgeTextTtext = + (textVal, ttextHex) -> ttextCompare(textVal, ttextHex, functions::tge_text_ttext); + + // ttext op text + public static final UDF2 teqTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::teq_ttext_text); + public static final UDF2 tneTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::tne_ttext_text); + public static final UDF2 tltTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::tlt_ttext_text); + public static final UDF2 tleTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::tle_ttext_text); + public static final UDF2 tgtTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::tgt_ttext_text); + public static final UDF2 tgeTtextText = + (ttextHex, textVal) -> ttextCompareRev(ttextHex, textVal, functions::tge_ttext_text); + + public static void registerAll(SparkSession spark) { + spark.udf().register("ttextUpper", ttextUpper, DataTypes.StringType); + spark.udf().register("ttextLower", ttextLower, DataTypes.StringType); + spark.udf().register("ttextInitcap", ttextInitcap, DataTypes.StringType); + // text op ttext comparison operators + spark.udf().register("teqTextTtext", teqTextTtext, DataTypes.StringType); + spark.udf().register("tneTextTtext", tneTextTtext, DataTypes.StringType); + spark.udf().register("tltTextTtext", tltTextTtext, DataTypes.StringType); + spark.udf().register("tleTextTtext", tleTextTtext, DataTypes.StringType); + spark.udf().register("tgtTextTtext", tgtTextTtext, DataTypes.StringType); + spark.udf().register("tgeTextTtext", tgeTextTtext, DataTypes.StringType); + // ttext op text comparison operators + spark.udf().register("teqTtextText", teqTtextText, DataTypes.StringType); + spark.udf().register("tneTtextText", tneTtextText, DataTypes.StringType); + spark.udf().register("tltTtextText", tltTtextText, DataTypes.StringType); + spark.udf().register("tleTtextText", tleTtextText, DataTypes.StringType); + spark.udf().register("tgtTtextText", tgtTtextText, DataTypes.StringType); + spark.udf().register("tgeTtextText", tgeTtextText, DataTypes.StringType); + + // ttext concatenation (MEOS textcat_ttext_*) + spark.udf().register("ttextCatTtextText", ttextCatTtextText, DataTypes.StringType); + spark.udf().register("ttextCatTextTtext", ttextCatTextTtext, DataTypes.StringType); + spark.udf().register("ttextCatTtextTtext", ttextCatTtextTtext, DataTypes.StringType); + // MobilityDB SQL bare-name alias + spark.udf().register("ttextCat", ttextCatTtextTtext, DataTypes.StringType); + // textset concatenation + spark.udf().register("textsetCatTextsetText", textsetCatTextsetText, DataTypes.StringType); + spark.udf().register("textsetCatTextTextset", textsetCatTextTextset, DataTypes.StringType); + spark.udf().register("textsetCat", textsetCatTextsetText, DataTypes.StringType); + } + + public static final UDF2 textsetCatTextsetText = + (setHex, txt) -> { + if (setHex == null || txt == null) return null; + MeosThread.ensureReady(); + Pointer s = functions.set_from_hexwkb(setHex); + if (s == null) return null; + Pointer t = functions.cstring2text(txt); + if (t == null) { MeosMemory.free(s); return null; } + try { + Pointer r = functions.textcat_textset_text(s, t); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(s, t); } + }; + + public static final UDF2 textsetCatTextTextset = + (txt, setHex) -> { + if (txt == null || setHex == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.cstring2text(txt); + if (t == null) return null; + Pointer s = functions.set_from_hexwkb(setHex); + if (s == null) { MeosMemory.free(t); return null; } + try { + Pointer r = functions.textcat_text_textset(t, s); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(t, s); } + }; + + public static final UDF2 ttextCatTtextText = + (ttextHex, txt) -> { + if (ttextHex == null || txt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(ttextHex); + if (p == null) return null; + Pointer t = functions.cstring2text(txt); + if (t == null) { MeosMemory.free(p); return null; } + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.textcat_ttext_text(p, t); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p, t); } + }; + + public static final UDF2 ttextCatTextTtext = + (txt, ttextHex) -> { + if (txt == null || ttextHex == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.cstring2text(txt); + if (t == null) return null; + Pointer p = functions.temporal_from_hexwkb(ttextHex); + if (p == null) { MeosMemory.free(t); return null; } + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.textcat_text_ttext(t, p); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(t, p); } + }; + + public static final UDF2 ttextCatTtextTtext = + (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(h1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = org.mobilitydb.spark.MeosNative.INSTANCE.textcat_ttext_ttext(p1, p2); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p1, p2); } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TemporalBoxOpsUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TemporalBoxOpsUDFs.java new file mode 100644 index 00000000..376a41a0 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TemporalBoxOpsUDFs.java @@ -0,0 +1,190 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; + +/** + * Spark SQL UDFs for cross-type box-overlap predicates on temporal types. + * + * Coverage: 30 UDFs across 5 predicates (adjacent, contained, contains, + * overlaps, same) × 6 cross-types: + * tnumber × tnumber — value+time bounding-box compare + * numspan × tnumber — value-span × tnumber bbox + * tnumber × numspan — tnumber × value-span bbox + * tstzspan × temporal — time-span × temporal bbox + * temporal × tstzspan — temporal × time-span bbox + * temporal × temporal — temporal-vs-temporal bbox + * + * tbox×tnumber, tnumber×tbox, tbox×tbox already covered by TBoxOpsUDFs. + * + * MEOS function authority: meos/include/meos.h + */ +public final class TemporalBoxOpsUDFs { + + private TemporalBoxOpsUDFs() {} + + private static UDF2 spanTemporal(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.span_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 temporalSpan(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.span_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + private static UDF2 temporalTemporal(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(h1); if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { return fn.apply(p1, p2); } + finally { MeosMemory.free(p1, p2); } + }; + } + + // ------------------------------------------------------------------ + // tnumber × tnumber (5) + // ------------------------------------------------------------------ + + public static final UDF2 tnumberAdjacentTnumber = temporalTemporal(functions::adjacent_tnumber_tnumber); + public static final UDF2 tnumberContainsTnumber = temporalTemporal(functions::contains_tnumber_tnumber); + public static final UDF2 tnumberContainedTnumber = temporalTemporal(functions::contained_tnumber_tnumber); + public static final UDF2 tnumberOverlapsTnumber = temporalTemporal(functions::overlaps_tnumber_tnumber); + public static final UDF2 tnumberSameTnumber = temporalTemporal(functions::same_tnumber_tnumber); + + // ------------------------------------------------------------------ + // numspan × tnumber (5) + // ------------------------------------------------------------------ + + public static final UDF2 numspanAdjacentTnumber = spanTemporal(functions::adjacent_numspan_tnumber); + public static final UDF2 numspanContainsTnumber = spanTemporal(functions::contains_numspan_tnumber); + public static final UDF2 numspanContainedTnumber = spanTemporal(functions::contained_numspan_tnumber); + public static final UDF2 numspanOverlapsTnumber = spanTemporal(functions::overlaps_numspan_tnumber); + public static final UDF2 numspanSameTnumber = spanTemporal(functions::same_numspan_tnumber); + + // ------------------------------------------------------------------ + // tnumber × numspan (5) + // ------------------------------------------------------------------ + + public static final UDF2 tnumberAdjacentNumspan = temporalSpan(functions::adjacent_tnumber_numspan); + public static final UDF2 tnumberContainsNumspan = temporalSpan(functions::contains_tnumber_numspan); + public static final UDF2 tnumberContainedNumspan = temporalSpan(functions::contained_tnumber_numspan); + public static final UDF2 tnumberOverlapsNumspan = temporalSpan(functions::overlaps_tnumber_numspan); + public static final UDF2 tnumberSameNumspan = temporalSpan(functions::same_tnumber_numspan); + + // ------------------------------------------------------------------ + // tstzspan × temporal (5) + // ------------------------------------------------------------------ + + public static final UDF2 tstzspanAdjacentTemporal = spanTemporal(functions::adjacent_tstzspan_temporal); + public static final UDF2 tstzspanContainsTemporal = spanTemporal(functions::contains_tstzspan_temporal); + public static final UDF2 tstzspanContainedTemporal = spanTemporal(functions::contained_tstzspan_temporal); + public static final UDF2 tstzspanOverlapsTemporal = spanTemporal(functions::overlaps_tstzspan_temporal); + public static final UDF2 tstzspanSameTemporal = spanTemporal(functions::same_tstzspan_temporal); + + // ------------------------------------------------------------------ + // temporal × tstzspan (5) + // ------------------------------------------------------------------ + + public static final UDF2 temporalAdjacentTstzspan = temporalSpan(functions::adjacent_temporal_tstzspan); + public static final UDF2 temporalContainsTstzspan = temporalSpan(functions::contains_temporal_tstzspan); + public static final UDF2 temporalContainedTstzspan = temporalSpan(functions::contained_temporal_tstzspan); + public static final UDF2 temporalOverlapsTstzspan = temporalSpan(functions::overlaps_temporal_tstzspan); + public static final UDF2 temporalSameTstzspan = temporalSpan(functions::same_temporal_tstzspan); + + // ------------------------------------------------------------------ + // temporal × temporal (5) + // ------------------------------------------------------------------ + + public static final UDF2 temporalAdjacentTemporal = temporalTemporal(functions::adjacent_temporal_temporal); + public static final UDF2 temporalContainsTemporal = temporalTemporal(functions::contains_temporal_temporal); + public static final UDF2 temporalContainedTemporal = temporalTemporal(functions::contained_temporal_temporal); + public static final UDF2 temporalOverlapsTemporal = temporalTemporal(functions::overlaps_temporal_temporal); + public static final UDF2 temporalSameTemporal = temporalTemporal(functions::same_temporal_temporal); + + public static void registerAll(SparkSession spark) { + // tnumber × tnumber + spark.udf().register("tnumberAdjacentTnumber", tnumberAdjacentTnumber, DataTypes.BooleanType); + spark.udf().register("tnumberContainsTnumber", tnumberContainsTnumber, DataTypes.BooleanType); + spark.udf().register("tnumberContainedTnumber", tnumberContainedTnumber, DataTypes.BooleanType); + spark.udf().register("tnumberOverlapsTnumber", tnumberOverlapsTnumber, DataTypes.BooleanType); + spark.udf().register("tnumberSameTnumber", tnumberSameTnumber, DataTypes.BooleanType); + // numspan × tnumber + spark.udf().register("numspanAdjacentTnumber", numspanAdjacentTnumber, DataTypes.BooleanType); + spark.udf().register("numspanContainsTnumber", numspanContainsTnumber, DataTypes.BooleanType); + spark.udf().register("numspanContainedTnumber", numspanContainedTnumber, DataTypes.BooleanType); + spark.udf().register("numspanOverlapsTnumber", numspanOverlapsTnumber, DataTypes.BooleanType); + spark.udf().register("numspanSameTnumber", numspanSameTnumber, DataTypes.BooleanType); + // tnumber × numspan + spark.udf().register("tnumberAdjacentNumspan", tnumberAdjacentNumspan, DataTypes.BooleanType); + spark.udf().register("tnumberContainsNumspan", tnumberContainsNumspan, DataTypes.BooleanType); + spark.udf().register("tnumberContainedNumspan", tnumberContainedNumspan, DataTypes.BooleanType); + spark.udf().register("tnumberOverlapsNumspan", tnumberOverlapsNumspan, DataTypes.BooleanType); + spark.udf().register("tnumberSameNumspan", tnumberSameNumspan, DataTypes.BooleanType); + // tstzspan × temporal + spark.udf().register("tstzspanAdjacentTemporal", tstzspanAdjacentTemporal, DataTypes.BooleanType); + spark.udf().register("tstzspanContainsTemporal", tstzspanContainsTemporal, DataTypes.BooleanType); + spark.udf().register("tstzspanContainedTemporal", tstzspanContainedTemporal, DataTypes.BooleanType); + spark.udf().register("tstzspanOverlapsTemporal", tstzspanOverlapsTemporal, DataTypes.BooleanType); + spark.udf().register("tstzspanSameTemporal", tstzspanSameTemporal, DataTypes.BooleanType); + // temporal × tstzspan + spark.udf().register("temporalAdjacentTstzspan", temporalAdjacentTstzspan, DataTypes.BooleanType); + spark.udf().register("temporalContainsTstzspan", temporalContainsTstzspan, DataTypes.BooleanType); + spark.udf().register("temporalContainedTstzspan", temporalContainedTstzspan, DataTypes.BooleanType); + spark.udf().register("temporalOverlapsTstzspan", temporalOverlapsTstzspan, DataTypes.BooleanType); + spark.udf().register("temporalSameTstzspan", temporalSameTstzspan, DataTypes.BooleanType); + // temporal × temporal — superseded 1:1 by the portable bare names + // adjacent/contains/contained/overlaps/same, registered by + // org.mobilitydb.spark.portable.PortableOperatorAliasUDFs reusing + // these very backing fields (one bare name, all six families). + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TemporalCompUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TemporalCompUDFs.java new file mode 100644 index 00000000..05214d58 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TemporalCompUDFs.java @@ -0,0 +1,238 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; + +import java.util.function.BiFunction; +import java.util.function.ObjDoubleConsumer; + +/** + * Spark SQL UDFs for temporal comparison operators (`teq`, `tne`, `tlt`, + * `tle`, `tgt`, `tge`) returning a temporal boolean (hex-WKB tbool). + * + * MobilityDB exposes `temporal_teq(value, temporal)` and operators `#=`, + * `#<>`, etc. Spark SQL has no operator extension API, so these are + * registered as named UDFs. Equality/inequality are symmetric so only the + * forward direction (temporal first) is provided. + * + * MEOS function authority: meos/include/meos.h — teq_tint_int, teq_tfloat_float, + * teq_ttext_text, teq_tbool_bool, teq_temporal_temporal, and similarly + * for tne/tlt/tle/tgt/tge. + */ +public final class TemporalCompUDFs { + + private TemporalCompUDFs() {} + + // ------------------------------------------------------------------ + // Helpers — five families based on right-hand input type. + // ------------------------------------------------------------------ + + private static UDF2 hexInt(BiFunction fn) { + return (hex, v) -> { + if (hex == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = fn.apply(p, v); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + } + + private static UDF2 hexDouble(java.util.function.ToDoubleBiFunction _unused) { + // Not used — Java's BiFunction with primitive double is awkward; we + // inline the double calls below instead. + return null; + } + + @FunctionalInterface + private interface PointerDoubleFn { Pointer apply(Pointer a, double b); } + @FunctionalInterface + private interface PointerBoolFn { Pointer apply(Pointer a, boolean b); } + + private static UDF2 hexFloat(PointerDoubleFn fn) { + return (hex, v) -> { + if (hex == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = fn.apply(p, v); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + } + + private static UDF2 hexBool(PointerBoolFn fn) { + return (hex, v) -> { + if (hex == null || v == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = fn.apply(p, v); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + } + + private static UDF2 hexText(BiFunction fn) { + return (hex, txt) -> { + if (hex == null || txt == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + Pointer t = functions.cstring2text(txt); + if (t == null) { MeosMemory.free(p); return null; } + try { + Pointer r = fn.apply(p, t); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p, t); } + }; + } + + private static UDF2 hexHex(BiFunction fn) { + return (h1, h2) -> { + if (h1 == null || h2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = functions.temporal_from_hexwkb(h1); + if (p1 == null) return null; + Pointer p2 = functions.temporal_from_hexwkb(h2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + Pointer r = fn.apply(p1, p2); + if (r == null) return null; + try { return functions.temporal_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p1, p2); } + }; + } + + // ------------------------------------------------------------------ + // teq — temporal equality + // ------------------------------------------------------------------ + + public static final UDF2 teqTintInt = hexInt(functions::teq_tint_int); + public static final UDF2 teqTfloatFloat = hexFloat(functions::teq_tfloat_float); + public static final UDF2 teqTboolBool = hexBool(functions::teq_tbool_bool); + public static final UDF2 teqTtextText = hexText(functions::teq_ttext_text); + public static final UDF2 teqTemporal = hexHex(functions::teq_temporal_temporal); + + // ------------------------------------------------------------------ + // tne — temporal inequality + // ------------------------------------------------------------------ + + public static final UDF2 tneTintInt = hexInt(functions::tne_tint_int); + public static final UDF2 tneTfloatFloat = hexFloat(functions::tne_tfloat_float); + public static final UDF2 tneTboolBool = hexBool(functions::tne_tbool_bool); + public static final UDF2 tneTtextText = hexText(functions::tne_ttext_text); + public static final UDF2 tneTemporal = hexHex(functions::tne_temporal_temporal); + + // ------------------------------------------------------------------ + // tlt — temporal less-than + // ------------------------------------------------------------------ + + public static final UDF2 tltTintInt = hexInt(functions::tlt_tint_int); + public static final UDF2 tltTfloatFloat = hexFloat(functions::tlt_tfloat_float); + public static final UDF2 tltTtextText = hexText(functions::tlt_ttext_text); + public static final UDF2 tltTemporal = hexHex(functions::tlt_temporal_temporal); + + // ------------------------------------------------------------------ + // tle — temporal less-or-equal + // ------------------------------------------------------------------ + + public static final UDF2 tleTintInt = hexInt(functions::tle_tint_int); + public static final UDF2 tleTfloatFloat = hexFloat(functions::tle_tfloat_float); + public static final UDF2 tleTtextText = hexText(functions::tle_ttext_text); + public static final UDF2 tleTemporal = hexHex(functions::tle_temporal_temporal); + + // ------------------------------------------------------------------ + // tgt — temporal greater-than + // ------------------------------------------------------------------ + + public static final UDF2 tgtTintInt = hexInt(functions::tgt_tint_int); + public static final UDF2 tgtTfloatFloat = hexFloat(functions::tgt_tfloat_float); + public static final UDF2 tgtTtextText = hexText(functions::tgt_ttext_text); + public static final UDF2 tgtTemporal = hexHex(functions::tgt_temporal_temporal); + + // ------------------------------------------------------------------ + // tge — temporal greater-or-equal + // ------------------------------------------------------------------ + + public static final UDF2 tgeTintInt = hexInt(functions::tge_tint_int); + public static final UDF2 tgeTfloatFloat = hexFloat(functions::tge_tfloat_float); + public static final UDF2 tgeTtextText = hexText(functions::tge_ttext_text); + public static final UDF2 tgeTemporal = hexHex(functions::tge_temporal_temporal); + + public static void registerAll(SparkSession spark) { + // teq + spark.udf().register("teqTintInt", teqTintInt, DataTypes.StringType); + spark.udf().register("teqTfloatFloat", teqTfloatFloat, DataTypes.StringType); + spark.udf().register("teqTboolBool", teqTboolBool, DataTypes.StringType); + spark.udf().register("teqTtextText", teqTtextText, DataTypes.StringType); + // tne + spark.udf().register("tneTintInt", tneTintInt, DataTypes.StringType); + spark.udf().register("tneTfloatFloat", tneTfloatFloat, DataTypes.StringType); + spark.udf().register("tneTboolBool", tneTboolBool, DataTypes.StringType); + spark.udf().register("tneTtextText", tneTtextText, DataTypes.StringType); + // tlt + spark.udf().register("tltTintInt", tltTintInt, DataTypes.StringType); + spark.udf().register("tltTfloatFloat", tltTfloatFloat, DataTypes.StringType); + spark.udf().register("tltTtextText", tltTtextText, DataTypes.StringType); + // tle + spark.udf().register("tleTintInt", tleTintInt, DataTypes.StringType); + spark.udf().register("tleTfloatFloat", tleTfloatFloat, DataTypes.StringType); + spark.udf().register("tleTtextText", tleTtextText, DataTypes.StringType); + // tgt + spark.udf().register("tgtTintInt", tgtTintInt, DataTypes.StringType); + spark.udf().register("tgtTfloatFloat", tgtTfloatFloat, DataTypes.StringType); + spark.udf().register("tgtTtextText", tgtTtextText, DataTypes.StringType); + // tge + spark.udf().register("tgeTintInt", tgeTintInt, DataTypes.StringType); + spark.udf().register("tgeTfloatFloat", tgeTfloatFloat, DataTypes.StringType); + spark.udf().register("tgeTtextText", tgeTtextText, DataTypes.StringType); + // The temporal × temporal forms teq/tne/tlt/tle/tgt/tge are + // superseded 1:1 by the portable bare names, registered by + // org.mobilitydb.spark.portable.PortableOperatorAliasUDFs reusing + // these very backing fields (one bare name, all six families). + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TemporalUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TemporalUDFs.java new file mode 100644 index 00000000..ab77e2c3 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TemporalUDFs.java @@ -0,0 +1,351 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.types.DataTypes; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +import java.sql.Timestamp; + +/** + * Spark SQL UDFs for generic temporal operations (type-agnostic). + * + * Storage convention: temporal values are hex-WKB strings produced by + * temporal_as_hexwkb(ptr, (byte) 0) and parsed back with + * temporal_from_hexwkb(hex). + * + * Epoch note: MEOS uses PostgreSQL epoch (µs since 2000-01-01); Spark uses + * UNIX epoch (ms since 1970-01-01). Conversion is done via pg_timestamptz_in() + * which stores the raw PG-epoch value in the OffsetDateTime's seconds field. + * Never call toEpochSecond() on a java.sql.Timestamp and pass it directly. + * + * MEOS function authority: meos/include/meos.h + * JMEOS PR: github.com/MobilityDB/JMEOS/pull/9 + */ +public final class TemporalUDFs { + + private TemporalUDFs() {} + + // PG epoch is 2000-01-01; Unix epoch is 1970-01-01. Difference = 946684800 s. + // JMEOS stores PG-epoch µs in the OffsetDateTime's epoch-seconds field. + private static final long PG_UNIX_EPOCH_OFFSET_MS = 946684800L * 1000L; + + /** Convert a JMEOS OffsetDateTime (PG-epoch µs in epoch-seconds field) to Spark Timestamp. */ + static Timestamp fromJmeosTimestamp(java.time.OffsetDateTime odt) { + // odt.toEpochSecond() holds the raw PG-epoch µs (not real seconds). + long unixEpochMillis = odt.toEpochSecond() / 1000L + PG_UNIX_EPOCH_OFFSET_MS; + return new Timestamp(unixEpochMillis); + } + + // ------------------------------------------------------------------ + // atTime(trip STRING, timeArg STRING|TIMESTAMP) → STRING + // + // timeArg may be: + // - java.sql.Timestamp (Q3: QueryInstants.instant column, Spark TIMESTAMP type) + // - String span literal "[t1,t2]"/"(t1,t2]"/... (Q7: QueryPeriods.period) + // - String instant literal "YYYY-MM-DD HH:MM:SS+TZ" (plain string instant) + // + // MEOS: tstzspan_in + temporal_at_tstzspan (span case) + // temporal_at_timestamptz (instant case) + // ------------------------------------------------------------------ + public static final UDF2 atTime = + (trip, timeArg) -> { + if (trip == null || timeArg == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer result; + if (timeArg instanceof java.sql.Timestamp) { + long pgEpochMicros = (((java.sql.Timestamp) timeArg).getTime() - 946684800L * 1000L) * 1000L; + java.time.OffsetDateTime odt = java.time.OffsetDateTime.ofInstant( + java.time.Instant.ofEpochSecond(pgEpochMicros, 0), + java.time.ZoneOffset.UTC); + result = functions.temporal_at_timestamptz(tptr, odt); + } else { + String s = timeArg.toString().trim(); + if (!s.isEmpty() && (s.charAt(0) == '[' || s.charAt(0) == '(')) { + Pointer spanPtr = functions.tstzspan_in(s); + if (spanPtr == null) return null; + try { + result = functions.temporal_at_tstzspan(tptr, spanPtr); + } finally { + MeosMemory.free(spanPtr); + } + } else { + java.time.OffsetDateTime odt = functions.pg_timestamptz_in(s, -1); + if (odt == null) return null; + result = functions.temporal_at_timestamptz(tptr, odt); + } + } + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // startTimestamp(trip STRING) → TIMESTAMP + // + // MEOS: temporal_start_timestamptz(const Temporal *) → TimestampTz + // ------------------------------------------------------------------ + public static final UDF1 startTimestamp = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return fromJmeosTimestamp(functions.temporal_start_timestamptz(ptr)); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // endTimestamp(trip STRING) → TIMESTAMP + // + // MEOS: temporal_end_timestamptz(const Temporal *) → TimestampTz + // ------------------------------------------------------------------ + public static final UDF1 endTimestamp = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return fromJmeosTimestamp(functions.temporal_end_timestamptz(ptr)); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // numInstants(trip STRING) → INT + // + // MEOS: temporal_num_instants(const Temporal *) → int + // ------------------------------------------------------------------ + public static final UDF1 numInstants = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_num_instants(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // speed(trip STRING) → STRING (hex-WKB of tfloat) + // + // MEOS: tpoint_speed(const Temporal *) → Temporal * (tfloat) + // ------------------------------------------------------------------ + public static final UDF1 speed = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + Pointer result = functions.tpoint_speed(ptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // atGeometry(trip STRING, geomWKT STRING) → STRING + // + // Restricts a tgeompoint to the instants when it was inside geomWkt. + // + // MEOS: geo_from_text(const char *, int32_t) → GSERIALIZED * + // tgeo_at_geom(const Temporal *, const GSERIALIZED *) → Temporal * + // ------------------------------------------------------------------ + public static final UDF2 atGeometry = + (trip, geomWkt) -> { + if (trip == null || geomWkt == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(trip); + if (tptr == null) return null; + try { + Pointer gptr = functions.geo_from_text(geomWkt, 0); + if (gptr == null) return null; + try { + Pointer result = functions.tgeo_at_geom(tptr, gptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(gptr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // asHexWKB(trip STRING) → STRING + // + // Serializes a temporal value to the canonical MEOS hex-WKB string + // (little-endian, variant 0) — byte-for-byte identical across all platforms. + // + // MEOS: temporal_as_hexwkb(const Temporal *, uint8_t variant) → char * + // ------------------------------------------------------------------ + public static final UDF1 asHexWKB = + (trip) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_as_hexwkb(ptr, (byte) 0); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // MFJSON output (hex-WKB in → JSON string out) + // + // MEOS: temporal_as_mfjson(temp, withbbox, flags, precision, srs) + // flags=0 → WKT geometry (not EWKT), precision controls decimal places + // ------------------------------------------------------------------ + + public static final UDF2 temporalAsMfjson = + (trip, precision) -> { + if (trip == null) return null; + MeosThread.ensureReady(); + int prec = (precision == null) ? 6 : precision; + Pointer ptr = functions.temporal_from_hexwkb(trip); + if (ptr == null) return null; + try { + return functions.temporal_as_mfjson(ptr, false, 0, prec, null); + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Text output (hex-WKB in → WKT-like text string out) + // + // MEOS: tbool_out, tint_out, tfloat_out (with precision), ttext_out + // These mirror the PostgreSQL temporal type output functions. + // ------------------------------------------------------------------ + + public static final UDF1 tboolOut = + (tbool) -> { + if (tbool == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tbool); + if (ptr == null) return null; + try { + return functions.tbool_out(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 tintOut = + (tint) -> { + if (tint == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(tint); + if (ptr == null) return null; + try { + return functions.tint_out(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF2 tfloatOut = + (tfloat, precision) -> { + if (tfloat == null) return null; + MeosThread.ensureReady(); + int prec = (precision == null) ? 6 : precision; + Pointer ptr = functions.temporal_from_hexwkb(tfloat); + if (ptr == null) return null; + try { + return functions.tfloat_out(ptr, prec); + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF1 ttextOut = + (ttext) -> { + if (ttext == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(ttext); + if (ptr == null) return null; + try { + return functions.ttext_out(ptr); + } finally { + MeosMemory.free(ptr); + } + }; + + public static void registerAll(org.apache.spark.sql.SparkSession spark) { + spark.udf().register("atTime", atTime, DataTypes.StringType); + spark.udf().register("startTimestamp", startTimestamp, DataTypes.TimestampType); + spark.udf().register("endTimestamp", endTimestamp, DataTypes.TimestampType); + spark.udf().register("numInstants", numInstants, DataTypes.IntegerType); + spark.udf().register("speed", speed, DataTypes.StringType); + spark.udf().register("atGeometry", atGeometry, DataTypes.StringType); + spark.udf().register("asHexWKB", asHexWKB, DataTypes.StringType); + spark.udf().register("temporalAsMfjson", temporalAsMfjson, DataTypes.StringType); + spark.udf().register("tboolOut", tboolOut, DataTypes.StringType); + spark.udf().register("tintOut", tintOut, DataTypes.StringType); + spark.udf().register("tfloatOut", tfloatOut, DataTypes.StringType); + spark.udf().register("ttextOut", ttextOut, DataTypes.StringType); + + // MobilityDB SQL bare-name aliases for temporal-instant accessors + // (work for any single-instant temporal value) + spark.udf().register("getTimestamp", startTimestamp, DataTypes.TimestampType); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TileUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TileUDFs.java new file mode 100644 index 00000000..f3dbe510 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TileUDFs.java @@ -0,0 +1,934 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosNative; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.api.java.UDF4; +import org.apache.spark.sql.api.java.UDF5; +import org.apache.spark.sql.api.java.UDF6; +import org.apache.spark.sql.api.java.UDF7; +import org.apache.spark.sql.api.java.UDF8; +import org.apache.spark.sql.api.java.UDF9; +import org.apache.spark.sql.types.DataTypes; + +import java.sql.Timestamp; + +/** + * Spark SQL UDFs for multidimensional tiling — split a temporal value into + * fixed-size cells (in space, time, value, or combinations) so the resulting + * cells can be processed in parallel and the per-cell results merged. + * + * The "boxes" variants return the bounding STBox/TBox of each cell that the + * temporal value intersects (lighter-weight, preserves no instants). + * The "split" variants (in {@link AccessorAliasUDFs}) return an array of + * sub-temporal values, one per cell. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h, + * meos/include/meos_internal.h + */ +public final class TileUDFs { + + private TileUDFs() {} + + private static final int STBOX_SIZE = 80; + private static final int TBOX_SIZE = 56; + + private static long pgEpoch(Timestamp ts) { + return (ts.getTime() - 946684800L * 1000L) * 1000L; + } + + // ------------------------------------------------------------------ + // Single-tile lookups + // ------------------------------------------------------------------ + + // getTimeTile(timestamptz, intervalStr, originTs) → STBox hex (the cell + // containing this timestamp at the given resolution) + public static final UDF3 getTimeTile = + (t, intervalStr, torigin) -> { + if (t == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + try { + Pointer r = MeosNative.INSTANCE.stbox_get_time_tile(pgEpoch(t), iv, pgEpoch(torigin)); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + } finally { MeosMemory.free(iv); } + }; + + // getSpaceTile(pointWKT, xsize, ysize, zsize, originPointWKT) → STBox hex + public static final UDF5 getSpaceTile = + (pointWkt, xsize, ysize, zsize, originWkt) -> { + if (pointWkt == null || xsize == null || ysize == null || zsize == null) return null; + MeosThread.ensureReady(); + Pointer pt = functions.geo_from_text(pointWkt, 0); + if (pt == null) return null; + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + Pointer r = MeosNative.INSTANCE.stbox_get_space_tile(pt, xsize, ysize, zsize, origin); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + } finally { + MeosMemory.free(pt); + if (origin != null) MeosMemory.free(origin); + } + }; + + // getSpaceTimeTile(pointWKT, t, xsize, ysize, zsize, intervalStr, originPointWKT, torigin) → STBox hex + public static final UDF8 + getSpaceTimeTile = (pointWkt, t, xsize, ysize, zsize, intervalStr, originWkt, torigin) -> { + if (pointWkt == null || t == null || xsize == null || ysize == null || zsize == null + || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer pt = functions.geo_from_text(pointWkt, 0); + if (pt == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(pt); return null; } + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + Pointer r = MeosNative.INSTANCE.stbox_get_space_time_tile( + pt, pgEpoch(t), xsize, ysize, zsize, iv, origin, pgEpoch(torigin)); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.stbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + } finally { + MeosMemory.free(pt, iv); + if (origin != null) MeosMemory.free(origin); + } + }; + + // ------------------------------------------------------------------ + // Multi-tile bounding-box arrays + // ------------------------------------------------------------------ + + // spaceBoxes(tgeo, xsize, ysize, zsize, originPointWKT, bitmatrix, borderInc) → STBox[] + public static final UDF7 + spaceBoxes = (trip, xsize, ysize, zsize, originWkt, bitmatrix, borderInc) -> { + if (trip == null || xsize == null || ysize == null || zsize == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tgeo_space_boxes(t, xsize, ysize, zsize, origin, + bitmatrix != null && bitmatrix, borderInc == null ? true : borderInc, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { + MeosMemory.free(t); + if (origin != null) MeosMemory.free(origin); + } + }; + + // spaceTimeBoxes(tgeo, xsize, ysize, zsize, intervalStr, originPointWKT, torigin, bitmatrix, borderInc) → STBox[] + public static final UDF9 + spaceTimeBoxes = (trip, xsize, ysize, zsize, intervalStr, originWkt, torigin, bitmatrix, borderInc) -> { + if (trip == null || xsize == null || ysize == null || zsize == null + || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tgeo_space_time_boxes( + t, xsize, ysize, zsize, iv, origin, pgEpoch(torigin), + bitmatrix != null && bitmatrix, borderInc == null ? true : borderInc, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { + MeosMemory.free(t, iv); + if (origin != null) MeosMemory.free(origin); + } + }; + + // valueTimeBoxesTfloat(tfloat, vsize, intervalStr, vorigin, torigin) → TBox[] + // Datum vsize/vorigin: float Datum is the IEEE 754 bits via doubleToLongBits. + public static final UDF5 + valueTimeBoxesTfloat = (trip, vsize, intervalStr, vorigin, torigin) -> { + if (trip == null || vsize == null || intervalStr == null || vorigin == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tnumber_value_time_boxes( + t, Double.doubleToLongBits(vsize), iv, + Double.doubleToLongBits(vorigin), pgEpoch(torigin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t, iv); } + }; + + // valueTimeBoxesTint(tint, vsize, intervalStr, vorigin, torigin) → TBox[] + public static final UDF5 + valueTimeBoxesTint = (trip, vsize, intervalStr, vorigin, torigin) -> { + if (trip == null || vsize == null || intervalStr == null || vorigin == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tnumber_value_time_boxes( + t, vsize.longValue(), iv, vorigin.longValue(), pgEpoch(torigin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t, iv); } + }; + + // ------------------------------------------------------------------ + // Splits — return Temporal** array (each element is a pointer to a + // sub-temporal value). Iterate by reading 8-byte pointers and + // dereferencing each. + // ------------------------------------------------------------------ + + // timeSplit(temporal, intervalStr, torigin) → array of temporal hex-WKB + public static final UDF3 + timeSplit = (trip, intervalStr, torigin) -> { + if (trip == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer binsOut = rt.getMemoryManager().allocateDirect(8); + Pointer arr = MeosNative.INSTANCE.temporal_time_split(t, iv, pgEpoch(torigin), binsOut, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { + MeosMemory.free(arr); + Pointer bins = binsOut.getPointer(0); + if (bins != null) MeosMemory.free(bins); + } + } finally { MeosMemory.free(t, iv); } + }; + + // spaceSplit(tgeo, xsize, ysize, zsize, originPointWKT, bitmatrix, borderInc) → array of temporal hex-WKB + public static final UDF7 + spaceSplit = (trip, xsize, ysize, zsize, originWkt, bitmatrix, borderInc) -> { + if (trip == null || xsize == null || ysize == null || zsize == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer binsOut = rt.getMemoryManager().allocateDirect(8); + Pointer arr = MeosNative.INSTANCE.tgeo_space_split(t, xsize, ysize, zsize, origin, + bitmatrix != null && bitmatrix, borderInc == null ? true : borderInc, binsOut, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { + MeosMemory.free(arr); + Pointer bins = binsOut.getPointer(0); + if (bins != null) MeosMemory.free(bins); + } + } finally { + MeosMemory.free(t); + if (origin != null) MeosMemory.free(origin); + } + }; + + // spaceTimeSplit(tgeo, xsize, ysize, zsize, intervalStr, originPointWKT, torigin, bitmatrix, borderInc) → array + public static final UDF9 + spaceTimeSplit = (trip, xsize, ysize, zsize, intervalStr, originWkt, torigin, bitmatrix, borderInc) -> { + if (trip == null || xsize == null || ysize == null || zsize == null + || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer spaceBinsOut = rt.getMemoryManager().allocateDirect(8); + Pointer timeBinsOut = rt.getMemoryManager().allocateDirect(8); + Pointer arr = MeosNative.INSTANCE.tgeo_space_time_split( + t, xsize, ysize, zsize, iv, origin, pgEpoch(torigin), + bitmatrix != null && bitmatrix, borderInc == null ? true : borderInc, + spaceBinsOut, timeBinsOut, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { + MeosMemory.free(arr); + Pointer sb = spaceBinsOut.getPointer(0); + Pointer tb = timeBinsOut.getPointer(0); + if (sb != null) MeosMemory.free(sb); + if (tb != null) MeosMemory.free(tb); + } + } finally { + MeosMemory.free(t, iv); + if (origin != null) MeosMemory.free(origin); + } + }; + + // ------------------------------------------------------------------ + // Bounded tile-set generators — given a bounds box (STBox/TBox) and + // tile sizes, enumerate every tile in the bounds. These are the + // primary parallel-partitioning primitives. + // ------------------------------------------------------------------ + + // spaceTiles(boundsStboxHex, xsize, ysize, zsize, originPointWkt, borderInc) → STBox[] + public static final UDF6 + spaceTiles = (boundsHex, xsize, ysize, zsize, originWkt, borderInc) -> { + if (boundsHex == null || xsize == null || ysize == null || zsize == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.stbox_from_hexwkb(boundsHex); + if (b == null) return null; + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.stbox_space_tiles(b, xsize, ysize, zsize, origin, + borderInc == null ? true : borderInc, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { + MeosMemory.free(b); + if (origin != null) MeosMemory.free(origin); + } + }; + + // timeTiles(stbox, intervalStr, torigin, borderInc) → STBox[] + public static final UDF4 + stboxTimeTiles = (boundsHex, intervalStr, torigin, borderInc) -> { + if (boundsHex == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.stbox_from_hexwkb(boundsHex); + if (b == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(b); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.stbox_time_tiles(b, iv, pgEpoch(torigin), + borderInc == null ? true : borderInc, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(b, iv); } + }; + + // spaceTimeTiles(stbox, xsize, ysize, zsize, intervalStr, originPointWkt, torigin, borderInc) → STBox[] + public static final UDF8 + spaceTimeTiles = (boundsHex, xsize, ysize, zsize, intervalStr, originWkt, torigin, borderInc) -> { + if (boundsHex == null || xsize == null || ysize == null || zsize == null + || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.stbox_from_hexwkb(boundsHex); + if (b == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(b); return null; } + Pointer origin = (originWkt == null) ? null : functions.geo_from_text(originWkt, 0); + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.stbox_space_time_tiles(b, xsize, ysize, zsize, iv, + origin, pgEpoch(torigin), borderInc == null ? true : borderInc, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { + MeosMemory.free(b, iv); + if (origin != null) MeosMemory.free(origin); + } + }; + + // tboxTimeTiles(tbox, intervalStr, torigin) → TBox[] — value-bounded time tiling + public static final UDF3 + tintboxTimeTiles = (boundsHex, intervalStr, torigin) -> tboxTimeTilesImpl(boundsHex, intervalStr, torigin, false); + + public static final UDF3 + tfloatboxTimeTiles = (boundsHex, intervalStr, torigin) -> tboxTimeTilesImpl(boundsHex, intervalStr, torigin, true); + + private static String[] tboxTimeTilesImpl(String boundsHex, String intervalStr, Timestamp torigin, boolean isFloat) { + if (boundsHex == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.tbox_from_hexwkb(boundsHex); + if (b == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(b); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer arr = isFloat + ? MeosNative.INSTANCE.tfloatbox_time_tiles(b, iv, pgEpoch(torigin), countOut) + : MeosNative.INSTANCE.tintbox_time_tiles(b, iv, pgEpoch(torigin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = rt.getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(b, iv); } + } + + // makeSimple(tpoint) — returns array of simple sub-tpoints + public static final UDF1 makeSimple = + trip -> { + if (trip == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tpoint_make_simple(t, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(t); } + }; + + // timeBoxes(tnumber) → TBox[] — go through tnumber_to_tbox then tile by time. + // For tfloat default; tint variant uses tintbox. + public static final UDF3 + tfloatTimeBoxes = (trip, intervalStr, torigin) -> { + if (trip == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + Pointer box = MeosNative.INSTANCE.tnumber_to_tbox(t); + if (box == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tfloatbox_time_tiles(box, iv, pgEpoch(torigin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(box); } + } finally { MeosMemory.free(t, iv); } + }; + + public static final UDF3 + tintTimeBoxes = (trip, intervalStr, torigin) -> { + if (trip == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + Pointer box = MeosNative.INSTANCE.tnumber_to_tbox(t); + if (box == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tintbox_time_tiles(box, iv, pgEpoch(torigin), countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(box); } + } finally { MeosMemory.free(t, iv); } + }; + + // timeBoxes(tgeo, intervalStr, torigin, ...) → STBox[] — extract STBox first + public static final UDF3 + tgeoTimeBoxes = (trip, intervalStr, torigin) -> { + if (trip == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + Pointer box = functions.tspatial_to_stbox(t); + if (box == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.stbox_time_tiles(box, iv, pgEpoch(torigin), true, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.stbox_as_hexwkb(arr.slice(i * STBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(box); } + } finally { MeosMemory.free(t, iv); } + }; + + // tfloatValueTiles / tintValueTiles — value-only TBox tiling + public static final UDF3 + tfloatValueTiles = (boxHex, vsize, vorigin) -> { + if (boxHex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.tbox_from_hexwkb(boxHex); + if (b == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tfloatbox_value_tiles(b, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(b); } + }; + + public static final UDF3 + tintValueTiles = (boxHex, vsize, vorigin) -> { + if (boxHex == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer b = functions.tbox_from_hexwkb(boxHex); + if (b == null) return null; + try { + Pointer countOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(4); + Pointer arr = MeosNative.INSTANCE.tintbox_value_tiles(b, vsize, vorigin, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + for (int i = 0; i < n; i++) + out[i] = functions.tbox_as_hexwkb(arr.slice(i * TBOX_SIZE), (byte) 0, sizeOut); + return out; + } finally { MeosMemory.free(arr); } + } finally { MeosMemory.free(b); } + }; + + // tfloatValueSplit / tintValueSplit — Temporal** array of value-tiled sub-tnumbers. + // Datum vsize/vorigin: tfloat passes IEEE bits via doubleToLongBits; tint just .longValue(). + public static final UDF3 + tfloatValueSplit = (trip, vsize, vorigin) -> tnumberValueSplitImpl(trip, + Double.doubleToLongBits(vsize == null ? 0 : vsize), + Double.doubleToLongBits(vorigin == null ? 0 : vorigin), + vsize == null || vorigin == null); + + public static final UDF3 + tintValueSplit = (trip, vsize, vorigin) -> tnumberValueSplitImpl(trip, + vsize == null ? 0 : vsize.longValue(), + vorigin == null ? 0 : vorigin.longValue(), + vsize == null || vorigin == null); + + // tfloatValueTimeSplit / tintValueTimeSplit — Temporal** array of value+time-tiled sub-tnumbers + public static final org.apache.spark.sql.api.java.UDF5 + tfloatValueTimeSplit = (trip, vsize, intervalStr, vorigin, torigin) -> tnumberValueTimeSplitImpl(trip, + Double.doubleToLongBits(vsize == null ? 0 : vsize), intervalStr, + Double.doubleToLongBits(vorigin == null ? 0 : vorigin), torigin, + vsize == null || intervalStr == null || vorigin == null || torigin == null); + + public static final org.apache.spark.sql.api.java.UDF5 + tintValueTimeSplit = (trip, vsize, intervalStr, vorigin, torigin) -> tnumberValueTimeSplitImpl(trip, + vsize == null ? 0 : vsize.longValue(), intervalStr, + vorigin == null ? 0 : vorigin.longValue(), torigin, + vsize == null || intervalStr == null || vorigin == null || torigin == null); + + private static String[] tnumberValueTimeSplitImpl(String trip, long vsize, String intervalStr, + long vorigin, Timestamp torigin, boolean nullArgs) { + if (trip == null || nullArgs) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) { MeosMemory.free(t); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer vBinsOut = rt.getMemoryManager().allocateDirect(8); + Pointer tBinsOut = rt.getMemoryManager().allocateDirect(8); + Pointer arr = MeosNative.INSTANCE.tnumber_value_time_split(t, vsize, iv, vorigin, pgEpoch(torigin), + vBinsOut, tBinsOut, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { + MeosMemory.free(arr); + Pointer vb = vBinsOut.getPointer(0); + Pointer tb = tBinsOut.getPointer(0); + if (vb != null) MeosMemory.free(vb); + if (tb != null) MeosMemory.free(tb); + } + } finally { MeosMemory.free(t, iv); } + } + + private static String[] tnumberValueSplitImpl(String trip, long vsize, long vorigin, boolean nullArgs) { + if (trip == null || nullArgs) return null; + MeosThread.ensureReady(); + Pointer t = functions.temporal_from_hexwkb(trip); + if (t == null) return null; + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + Pointer binsOut = rt.getMemoryManager().allocateDirect(8); + Pointer arr = MeosNative.INSTANCE.tnumber_value_split(t, vsize, vorigin, binsOut, countOut); + if (arr == null) return null; + try { + int n = countOut.getInt(0); + String[] out = new String[n]; + for (int i = 0; i < n; i++) { + Pointer p = arr.getPointer(i * 8L); + if (p == null) continue; + out[i] = functions.temporal_as_hexwkb(p, (byte) 0); + MeosMemory.free(p); + } + return out; + } finally { + MeosMemory.free(arr); + Pointer bins = binsOut.getPointer(0); + if (bins != null) MeosMemory.free(bins); + } + } finally { MeosMemory.free(t); } + } + + // ------------------------------------------------------------------ + // Single-tile lookups via tbox_get_value_time_tile + // + // MeosType enum values used: T_FLOAT8=11, T_FLOATSPAN=13, + // T_INT4=15, T_INTSPAN=19. + // Datum vsize/vorigin: tfloat → IEEE bits via doubleToLongBits; + // tint → just longValue(). + // ------------------------------------------------------------------ + + private static final int T_FLOAT8 = 11, T_FLOATSPAN = 13, T_INT4 = 15, T_INTSPAN = 19; + + // getValueTile(v float, vsize float, vorigin float) → tbox hex + public static final UDF3 + getValueTileFloat = (v, vsize, vorigin) -> { + if (v == null || vsize == null || vorigin == null) return null; + MeosThread.ensureReady(); + Pointer r = MeosNative.INSTANCE.tbox_get_value_time_tile( + Double.doubleToLongBits(v), 0L, + Double.doubleToLongBits(vsize), null, + Double.doubleToLongBits(vorigin), 0L, + T_FLOAT8, T_FLOATSPAN); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + }; + + // getTBoxTimeTile(t timestamptz, duration interval, torigin timestamptz) → tbox hex + public static final UDF3 + getTBoxTimeTile = (t, intervalStr, torigin) -> { + if (t == null || intervalStr == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + try { + Pointer r = MeosNative.INSTANCE.tbox_get_value_time_tile( + 0L, pgEpoch(t), + 0L, iv, + 0L, pgEpoch(torigin), + T_FLOAT8, T_FLOATSPAN); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + } finally { MeosMemory.free(iv); } + }; + + // getValueTimeTile(v float, t timestamptz, vsize float, duration interval, + // vorigin float, torigin timestamptz) → tbox hex + public static final org.apache.spark.sql.api.java.UDF6 + getValueTimeTileFloat = (v, t, vsize, intervalStr, vorigin, torigin) -> { + if (v == null || t == null || vsize == null || intervalStr == null + || vorigin == null || torigin == null) return null; + MeosThread.ensureReady(); + Pointer iv = functions.pg_interval_in(intervalStr, -1); + if (iv == null) return null; + try { + Pointer r = MeosNative.INSTANCE.tbox_get_value_time_tile( + Double.doubleToLongBits(v), pgEpoch(t), + Double.doubleToLongBits(vsize), iv, + Double.doubleToLongBits(vorigin), pgEpoch(torigin), + T_FLOAT8, T_FLOATSPAN); + if (r == null) return null; + try { + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + return functions.tbox_as_hexwkb(r, (byte) 0, sizeOut); + } finally { MeosMemory.free(r); } + } finally { MeosMemory.free(iv); } + }; + + // ------------------------------------------------------------------ + // Analytics — geoMeasure + asMVTGeom + // ------------------------------------------------------------------ + + // geoMeasure(tpoint, measure, segmentize) → geometry hex (geomeasure encoding) + public static final org.apache.spark.sql.api.java.UDF3 + geoMeasure = (tpointHex, measureHex, segmentize) -> { + if (tpointHex == null || measureHex == null) return null; + MeosThread.ensureReady(); + Pointer tp = functions.temporal_from_hexwkb(tpointHex); + if (tp == null) return null; + Pointer m = functions.temporal_from_hexwkb(measureHex); + if (m == null) { MeosMemory.free(tp); return null; } + try { + Pointer outBuf = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + boolean ok = MeosNative.INSTANCE.tpoint_tfloat_to_geomeas( + tp, m, segmentize != null && segmentize, outBuf); + if (!ok) return null; + Pointer geo = outBuf.getPointer(0); + if (geo == null) return null; + try { return functions.geo_as_hexewkb(geo, "NDR"); } + finally { MeosMemory.free(geo); } + } finally { MeosMemory.free(tp, m); } + }; + + // asMVTGeom(tpoint, bounds, extent, buffer, clip_geom) → array of WKT geometries + // (the per-tile clipped tpoint trajectories) + public static final org.apache.spark.sql.api.java.UDF5 + asMVTGeom = (tpointHex, boundsHex, extent, buffer, clipGeom) -> { + if (tpointHex == null || boundsHex == null) return null; + MeosThread.ensureReady(); + Pointer tp = functions.temporal_from_hexwkb(tpointHex); + if (tp == null) return null; + Pointer b = functions.stbox_from_hexwkb(boundsHex); + if (b == null) { MeosMemory.free(tp); return null; } + try { + jnr.ffi.Runtime rt = Runtime.getSystemRuntime(); + Pointer gsArrOut = rt.getMemoryManager().allocateDirect(8); + Pointer timesArrOut = rt.getMemoryManager().allocateDirect(8); + Pointer countOut = rt.getMemoryManager().allocateDirect(4); + boolean ok = MeosNative.INSTANCE.tpoint_as_mvtgeom(tp, b, + extent == null ? 4096 : extent, buffer == null ? 256 : buffer, + clipGeom == null || clipGeom, gsArrOut, timesArrOut, countOut); + if (!ok) return null; + Pointer gsArr = gsArrOut.getPointer(0); + Pointer timesArr = timesArrOut.getPointer(0); + if (gsArr == null) return null; + int n = countOut.getInt(0); + String[] out = new String[n]; + try { + for (int i = 0; i < n; i++) { + Pointer gs = gsArr.getPointer(i * 8L); + if (gs == null) continue; + out[i] = functions.geo_as_text(gs, 6); + // GSERIALIZED ownership: gsArr is allocated by MEOS, each + // entry is owned by the array; do not free entries individually. + } + return out; + } finally { + MeosMemory.free(gsArr); + if (timesArr != null) MeosMemory.free(timesArr); + } + } finally { MeosMemory.free(tp, b); } + }; + + public static void registerAll(SparkSession spark) { + // Single-tile lookups + spark.udf().register("getTimeTile", getTimeTile, DataTypes.StringType); + spark.udf().register("getSpaceTile", getSpaceTile, DataTypes.StringType); + spark.udf().register("getSpaceTimeTile", getSpaceTimeTile, DataTypes.StringType); + // getStboxTimeTile alias for getTimeTile (covers MobilityDB SQL bare name) + spark.udf().register("getStboxTimeTile", getTimeTile, DataTypes.StringType); + // Multi-tile bounding boxes + spark.udf().register("spaceBoxes", spaceBoxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("spaceTimeBoxes", spaceTimeBoxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTimeBoxesTfloat", valueTimeBoxesTfloat, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTimeBoxesTint", valueTimeBoxesTint, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTimeBoxes", valueTimeBoxesTfloat, DataTypes.createArrayType(DataTypes.StringType)); + // Splits (return arrays of sub-temporal values) + spark.udf().register("timeSplit", timeSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("spaceSplit", spaceSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("spaceTimeSplit", spaceTimeSplit, DataTypes.createArrayType(DataTypes.StringType)); + // Bounded tile-set generators + spark.udf().register("spaceTiles", spaceTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("spaceTimeTiles", spaceTimeTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("stboxTimeTiles", stboxTimeTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintboxTimeTiles", tintboxTimeTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tfloatboxTimeTiles", tfloatboxTimeTiles, DataTypes.createArrayType(DataTypes.StringType)); + // Bare-name aliases (timeTiles defaults to STBox; users with TBox use stboxTimeTiles vs tboxTimeTiles explicitly) + spark.udf().register("timeTiles", stboxTimeTiles, DataTypes.createArrayType(DataTypes.StringType)); + // makeSimple + timeBoxes (typed dispatch via tnumber/tgeo) + spark.udf().register("makeSimple", makeSimple, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tfloatTimeBoxes", tfloatTimeBoxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintTimeBoxes", tintTimeBoxes, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tgeoTimeBoxes", tgeoTimeBoxes, DataTypes.createArrayType(DataTypes.StringType)); + // timeBoxes default = tgeo (returns STBox[]); for TBox callers use tfloatTimeBoxes/tintTimeBoxes + spark.udf().register("timeBoxes", tgeoTimeBoxes, DataTypes.createArrayType(DataTypes.StringType)); + // Value-only tile generators + spark.udf().register("tfloatValueTiles", tfloatValueTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintValueTiles", tintValueTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTiles", tfloatValueTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueBoxes", tfloatValueTiles, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTimeTiles", valueTimeBoxesTfloat, DataTypes.createArrayType(DataTypes.StringType)); + // Value splits (typed Temporal** arrays) + spark.udf().register("tfloatValueSplit", tfloatValueSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintValueSplit", tintValueSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueSplit", tfloatValueSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tfloatValueTimeSplit", tfloatValueTimeSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("tintValueTimeSplit", tintValueTimeSplit, DataTypes.createArrayType(DataTypes.StringType)); + spark.udf().register("valueTimeSplit", tfloatValueTimeSplit, DataTypes.createArrayType(DataTypes.StringType)); + // Single-tile lookups (defaults to float; tint variants would call with T_INT4/T_INTSPAN) + spark.udf().register("getValueTile", getValueTileFloat, DataTypes.StringType); + spark.udf().register("getTBoxTimeTile", getTBoxTimeTile, DataTypes.StringType); + spark.udf().register("getValueTimeTile", getValueTimeTileFloat, DataTypes.StringType); + // Analytics + spark.udf().register("geoMeasure", geoMeasure, DataTypes.StringType); + spark.udf().register("asMVTGeom", asMVTGeom, DataTypes.createArrayType(DataTypes.StringType)); + } +} diff --git a/src/main/java/org/mobilitydb/spark/temporal/TransformUDFs.java b/src/main/java/org/mobilitydb/spark/temporal/TransformUDFs.java new file mode 100644 index 00000000..7a61902a --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/temporal/TransformUDFs.java @@ -0,0 +1,1089 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import functions.functions; +import jnr.ffi.Pointer; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; +import org.apache.spark.sql.SparkSession; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.api.java.UDF2; +import org.apache.spark.sql.api.java.UDF3; +import org.apache.spark.sql.types.DataTypes; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; + +/** + * Spark SQL UDFs for converting and transforming temporal types. + * + * Covers: subtype conversion (to TInstant/TSequence/TSequenceSet), + * interpolation change, type casting (tfloat↔tint), value-domain + * shifting and scaling, time-domain shifting and scaling, SRID + * assignment, coordinate rounding, and trajectory simplification. + * + * All temporal values are encoded as hex-WKB Strings. Interpolation + * is expressed as a String: "Discrete", "Step", or "Linear". + * Interval arguments use PostgreSQL interval literal syntax, e.g. + * "1 day" or "01:00:00". + * + * Memory management: every native Pointer allocated by MEOS is freed + * via MeosMemory.free() in a finally block to prevent native heap + * leakage across UDF calls. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +public final class TransformUDFs { + + private TransformUDFs() {} + + // interpType constants from meos.h: DISCRETE=1, STEP=2, LINEAR=3 + private static int interpToInt(String interp) { + if ("Discrete".equalsIgnoreCase(interp)) return 1; + if ("Step".equalsIgnoreCase(interp)) return 2; + if ("Linear".equalsIgnoreCase(interp)) return 3; + throw new IllegalArgumentException("Unknown interpolation: " + interp); + } + + // ------------------------------------------------------------------ + // Subtype conversion + // ------------------------------------------------------------------ + + // temporalToTInstant(s STRING) → STRING + // MEOS: temporal_to_tinstant(const Temporal *) → TInstant * + public static final UDF1 temporalToTInstant = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_to_tinstant(ptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalToTSequence(s STRING, interp STRING) → STRING + // interp: "Discrete" | "Step" | "Linear" + // MEOS: temporal_to_tsequence(const Temporal *, interpType interp) → TSequence * + public static final UDF2 temporalToTSequence = + (s, interp) -> { + if (s == null || interp == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_to_tsequence(ptr, interp); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalToTSequenceSet(s STRING, interp STRING) → STRING + // interp: "Discrete" | "Step" | "Linear" + // MEOS: temporal_to_tsequenceset(const Temporal *, interpType interp) → TSequenceSet * + public static final UDF2 temporalToTSequenceSet = + (s, interp) -> { + if (s == null || interp == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_to_tsequenceset(ptr, interp); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Interpolation change + // ------------------------------------------------------------------ + + // temporalSetInterp(s STRING, interpStr STRING) → STRING + // interpStr: "Discrete" → 1, "Step" → 2, "Linear" → 3 + // MEOS: temporal_set_interp(const Temporal *, interpType interp) → Temporal * + public static final UDF2 temporalSetInterp = + (s, interpStr) -> { + if (s == null || interpStr == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + int interpInt = interpToInt(interpStr); + Pointer result = functions.temporal_set_interp(ptr, interpInt); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Type casting + // ------------------------------------------------------------------ + + // tfloatToTint(s STRING) → STRING + // MEOS: tfloat_to_tint(const Temporal *) → Temporal * + public static final UDF1 tfloatToTint = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tfloat_to_tint(ptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tintToTfloat(s STRING) → STRING + // MEOS: tint_to_tfloat(const Temporal *) → Temporal * + public static final UDF1 tintToTfloat = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tint_to_tfloat(ptr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Value-domain shifting and scaling (tint) + // + // MEOS: tint_shift_value(temp, shift) meos.h + // tint_scale_value(temp, width) meos.h + // tint_shift_scale_value(temp, s, w) meos.h + // ------------------------------------------------------------------ + + public static final UDF2 tintShiftValue = + (s, shift) -> { + if (s == null || shift == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tint_shift_value(ptr, shift); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF2 tintScaleValue = + (s, width) -> { + if (s == null || width == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tint_scale_value(ptr, width); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + public static final UDF3 tintShiftScaleValue = + (s, shift, width) -> { + if (s == null || shift == null || width == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tint_shift_scale_value(ptr, shift, width); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Value-domain shifting and scaling (tfloat) + // ------------------------------------------------------------------ + + // tfloatShiftValue(s STRING, shift DOUBLE) → STRING + // MEOS: tfloat_shift_value(const Temporal *, double) → Temporal * + public static final UDF2 tfloatShiftValue = + (s, shift) -> { + if (s == null || shift == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tfloat_shift_value(ptr, shift); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tfloatScaleValue(s STRING, width DOUBLE) → STRING + // MEOS: tfloat_scale_value(const Temporal *, double) → Temporal * + public static final UDF2 tfloatScaleValue = + (s, width) -> { + if (s == null || width == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tfloat_scale_value(ptr, width); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tfloatShiftScaleValue(s STRING, shift DOUBLE, width DOUBLE) → STRING + // MEOS: tfloat_shift_scale_value(const Temporal *, double shift, double width) → Temporal * + public static final UDF3 tfloatShiftScaleValue = + (s, shift, width) -> { + if (s == null || shift == null || width == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tfloat_shift_scale_value(ptr, shift, width); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Time-domain shifting and scaling + // ------------------------------------------------------------------ + + // temporalShiftTime(s STRING, shiftStr STRING) → STRING + // MEOS: temporal_shift_time(const Temporal *, const Interval *) → Temporal * + public static final UDF2 temporalShiftTime = + (s, shiftStr) -> { + if (s == null || shiftStr == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer shiftPtr = functions.pg_interval_in(shiftStr, -1); + if (shiftPtr == null) return null; + try { + Pointer result = functions.temporal_shift_time(tptr, shiftPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(shiftPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalScaleTime(s STRING, scaleStr STRING) → STRING + // MEOS: temporal_scale_time(const Temporal *, const Interval *) → Temporal * + public static final UDF2 temporalScaleTime = + (s, scaleStr) -> { + if (s == null || scaleStr == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer scalePtr = functions.pg_interval_in(scaleStr, -1); + if (scalePtr == null) return null; + try { + Pointer result = functions.temporal_scale_time(tptr, scalePtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(scalePtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // temporalShiftScaleTime(s STRING, shiftStr STRING, scaleStr STRING) → STRING + // shiftStr and scaleStr are PostgreSQL interval literals, e.g. "1 day". + // MEOS: temporal_shift_scale_time(const Temporal *, const Interval *, const Interval *) → Temporal * + public static final UDF3 temporalShiftScaleTime = + (s, shiftStr, scaleStr) -> { + if (s == null || shiftStr == null || scaleStr == null) return null; + MeosThread.ensureReady(); + Pointer tptr = functions.temporal_from_hexwkb(s); + if (tptr == null) return null; + try { + Pointer shiftPtr = functions.pg_interval_in(shiftStr, -1); + if (shiftPtr == null) return null; + try { + Pointer scalePtr = functions.pg_interval_in(scaleStr, -1); + if (scalePtr == null) return null; + try { + Pointer result = functions.temporal_shift_scale_time(tptr, shiftPtr, scalePtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(scalePtr); + } + } finally { + MeosMemory.free(shiftPtr); + } + } finally { + MeosMemory.free(tptr); + } + }; + + // ------------------------------------------------------------------ + // Spatial transformations (tpoint) + // ------------------------------------------------------------------ + + // tpointSetSrid(s STRING, srid INT) → STRING + // MEOS: tspatial_set_srid(const Temporal *, int32_t srid) → Temporal * + public static final UDF2 tpointSetSrid = + (s, srid) -> { + if (s == null || srid == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.tspatial_set_srid(ptr, srid); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tpointRound(s STRING, maxdd INT) → STRING + // MEOS: temporal_round(const Temporal *, int maxdd) → Temporal * + public static final UDF2 tpointRound = + (s, maxdd) -> { + if (s == null || maxdd == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_round(ptr, maxdd); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // Trajectory simplification + // ------------------------------------------------------------------ + + // temporalSimplifyDp(s STRING, dist DOUBLE) → STRING + // Uses the Douglas-Peucker algorithm with synchronized=false. + // MEOS: temporal_simplify_dp(const Temporal *, double eps_dist, bool synchronized) → Temporal * + public static final UDF2 temporalSimplifyDp = + (s, dist) -> { + if (s == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_simplify_dp(ptr, dist, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalSimplifyMaxDist(s STRING, dist DOUBLE) → STRING + // Uses maximum-distance simplification with synchronized=false. + // MEOS: temporal_simplify_max_dist(const Temporal *, double eps_dist, bool synchronized) → Temporal * + public static final UDF2 temporalSimplifyMaxDist = + (s, dist) -> { + if (s == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_simplify_max_dist(ptr, dist, false); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + private static final OffsetDateTime PG_EPOCH = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC); + + // temporalSimplifyMinDist(s STRING, dist DOUBLE) → STRING + // Removes consecutive instants whose distance is below the threshold. + // MEOS: temporal_simplify_min_dist(const Temporal *, double dist) → Temporal * + public static final UDF2 temporalSimplifyMinDist = + (s, dist) -> { + if (s == null || dist == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer result = functions.temporal_simplify_min_dist(ptr, dist); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalSimplifyMinTdelta(s STRING, durationStr STRING) → STRING + // Removes consecutive instants whose time delta is below the threshold. + // MEOS: temporal_simplify_min_tdelta(const Temporal *, const Interval *) → Temporal * + public static final UDF2 temporalSimplifyMinTdelta = + (s, durationStr) -> { + if (s == null || durationStr == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer ivPtr = functions.pg_interval_in(durationStr, -1); + if (ivPtr == null) return null; + try { + Pointer result = functions.temporal_simplify_min_tdelta(ptr, ivPtr); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ivPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalTPrecision(s STRING, durationStr STRING) → STRING + // Rounds all timestamps to the nearest multiple of the given duration. + // MEOS: temporal_tprecision(const Temporal *, const Interval *, TimestampTz origin) + public static final UDF2 temporalTPrecision = + (s, durationStr) -> { + if (s == null || durationStr == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer ivPtr = functions.pg_interval_in(durationStr, -1); + if (ivPtr == null) return null; + try { + Pointer result = functions.temporal_tprecision(ptr, ivPtr, PG_EPOCH); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ivPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // temporalTSample(s STRING, durationStr STRING, interpStr STRING) → STRING + // Re-samples a temporal value at regular time intervals. + // origin is fixed at 2000-01-01 00:00:00 UTC (MEOS/PG epoch). + // MEOS: temporal_tsample(const Temporal *, const Interval *, TimestampTz, interpType) → Temporal * + public static final UDF3 temporalTSample = + (s, durationStr, interpStr) -> { + if (s == null || durationStr == null || interpStr == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer ivPtr = functions.pg_interval_in(durationStr, -1); + if (ivPtr == null) return null; + try { + int interp; + switch (interpStr) { + case "Discrete": interp = 1; break; + case "Step": interp = 2; break; + default: interp = 3; break; + } + Pointer result = functions.temporal_tsample(ptr, ivPtr, PG_EPOCH, interp); + if (result == null) return null; + try { + return functions.temporal_as_hexwkb(result, (byte) 0); + } finally { + MeosMemory.free(result); + } + } finally { + MeosMemory.free(ivPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // tpointTrajectory(s STRING) → STRING (WKT of the trajectory geometry) + // For a tgeompoint sequence, this returns a LINESTRING or POINT geometry. + // MEOS: tpoint_trajectory(const Temporal *, bool unary_union) → GSERIALIZED * + public static final UDF1 tpointTrajectory = + (s) -> { + if (s == null) return null; + MeosThread.ensureReady(); + Pointer ptr = functions.temporal_from_hexwkb(s); + if (ptr == null) return null; + try { + Pointer gsPtr = functions.tpoint_trajectory(ptr, false); + if (gsPtr == null) return null; + try { + return functions.geo_as_text(gsPtr, 6); + } finally { + MeosMemory.free(gsPtr); + } + } finally { + MeosMemory.free(ptr); + } + }; + + // ------------------------------------------------------------------ + // floatset transforms + // ------------------------------------------------------------------ + + // floatsetCeil(setHex STRING) → STRING + // MEOS: floatset_ceil(const Set *) → Set * + public static final UDF1 floatsetCeil = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatset_ceil(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatsetFloor(setHex STRING) → STRING + // MEOS: floatset_floor(const Set *) → Set * + public static final UDF1 floatsetFloor = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatset_floor(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatsetDegrees(setHex STRING) → STRING (radians → degrees) + // MEOS: floatset_degrees(const Set *, bool normalize) → Set * + public static final UDF1 floatsetDegrees = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatset_degrees(p, false); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatsetRadians(setHex STRING) → STRING (degrees → radians) + // MEOS: floatset_radians(const Set *) → Set * + public static final UDF1 floatsetRadians = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatset_radians(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // textset transforms (case normalization) + // ------------------------------------------------------------------ + + // textsetLower(setHex STRING) → STRING (all elements lowercased) + // MEOS: textset_lower(const Set *) → Set * + public static final UDF1 textsetLower = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.textset_lower(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // textsetUpper(setHex STRING) → STRING (all elements uppercased) + // MEOS: textset_upper(const Set *) → Set * + public static final UDF1 textsetUpper = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.textset_upper(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // textsetInitcap(setHex STRING) → STRING (first letter of each element capitalized) + // MEOS: textset_initcap(const Set *) → Set * + public static final UDF1 textsetInitcap = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.textset_initcap(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // intspan / floatspan shift-scale + // ------------------------------------------------------------------ + + // intspanShiftScale(spanHex STRING, shift INTEGER, width INTEGER) → STRING + // MEOS: intspan_shift_scale(const Span *, int shift, int width, + // bool hasshift, bool haswidth) → Span * + public static final UDF3 intspanShiftScale = + (hex, shift, width) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + int s = (shift == null) ? 0 : shift; + int w = (width == null) ? 0 : width; + Pointer r = functions.intspan_shift_scale(p, s, w, + shift != null, width != null); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspanShiftScale(spanHex STRING, shift DOUBLE, width DOUBLE) → STRING + // MEOS: floatspan_shift_scale(const Span *, double, double, bool, bool) → Span * + public static final UDF3 floatspanShiftScale = + (hex, shift, width) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + double s = (shift == null) ? 0.0 : shift; + double w = (width == null) ? 0.0 : width; + Pointer r = functions.floatspan_shift_scale(p, s, w, + shift != null, width != null); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // intspanset / floatspanset shift-scale and type conversion + // ------------------------------------------------------------------ + + // intspansetShiftScale(hex STRING, shift INTEGER, width INTEGER) → STRING + // MEOS: intspanset_shift_scale(const SpanSet *, int, int, bool, bool) → SpanSet * + public static final UDF3 intspansetShiftScale = + (hex, shift, width) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + int s = (shift == null) ? 0 : shift; + int w = (width == null) ? 0 : width; + Pointer r = functions.intspanset_shift_scale(p, s, w, + shift != null, width != null); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspansetShiftScale(hex STRING, shift DOUBLE, width DOUBLE) → STRING + // MEOS: floatspanset_shift_scale(const SpanSet *, double, double, bool, bool) → SpanSet * + public static final UDF3 floatspansetShiftScale = + (hex, shift, width) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + double s = (shift == null) ? 0.0 : shift; + double w = (width == null) ? 0.0 : width; + Pointer r = functions.floatspanset_shift_scale(p, s, w, + shift != null, width != null); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspansetCeil(hex STRING) → STRING + // MEOS: floatspanset_ceil(const SpanSet *) → SpanSet * + public static final UDF1 floatspansetCeil = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatspanset_ceil(p); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspansetFloor(hex STRING) → STRING + // MEOS: floatspanset_floor(const SpanSet *) → SpanSet * + public static final UDF1 floatspansetFloor = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatspanset_floor(p); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspansetRound(hex STRING, maxDecimals INTEGER) → STRING + // MEOS: floatspanset_round(const SpanSet *, int) → SpanSet * + public static final UDF2 floatspansetRound = + (hex, decimals) -> { + if (hex == null || decimals == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatspanset_round(p, decimals); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // intspansetToFloat(hex STRING) → STRING (intspanset → floatspanset) + // MEOS: intspanset_to_floatspanset(const SpanSet *) → SpanSet * + public static final UDF1 intspansetToFloat = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.intspanset_to_floatspanset(p); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // floatspansetToInt(hex STRING) → STRING (floatspanset → intspanset) + // MEOS: floatspanset_to_intspanset(const SpanSet *) → SpanSet * + public static final UDF1 floatspansetToInt = + (hex) -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.spanset_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.floatspanset_to_intspanset(p); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + // ------------------------------------------------------------------ + // Registration + // ------------------------------------------------------------------ + + public static void registerAll(SparkSession spark) { + // Subtype conversion + spark.udf().register("temporalToTInstant", temporalToTInstant, DataTypes.StringType); + spark.udf().register("temporalToTSequence", temporalToTSequence, DataTypes.StringType); + spark.udf().register("temporalToTSequenceSet", temporalToTSequenceSet, DataTypes.StringType); + // Interpolation change + spark.udf().register("temporalSetInterp", temporalSetInterp, DataTypes.StringType); + // Type casting + spark.udf().register("tfloatToTint", tfloatToTint, DataTypes.StringType); + spark.udf().register("tintToTfloat", tintToTfloat, DataTypes.StringType); + // tint value-domain shifting and scaling + spark.udf().register("tintShiftValue", tintShiftValue, DataTypes.StringType); + spark.udf().register("tintScaleValue", tintScaleValue, DataTypes.StringType); + spark.udf().register("tintShiftScaleValue", tintShiftScaleValue, DataTypes.StringType); + // Value-domain shifting and scaling + spark.udf().register("tfloatShiftValue", tfloatShiftValue, DataTypes.StringType); + spark.udf().register("tfloatScaleValue", tfloatScaleValue, DataTypes.StringType); + spark.udf().register("tfloatShiftScaleValue", tfloatShiftScaleValue, DataTypes.StringType); + // Time-domain shifting and scaling + spark.udf().register("temporalShiftTime", temporalShiftTime, DataTypes.StringType); + spark.udf().register("temporalScaleTime", temporalScaleTime, DataTypes.StringType); + spark.udf().register("temporalShiftScaleTime", temporalShiftScaleTime, DataTypes.StringType); + // Spatial transformations + spark.udf().register("tpointSetSrid", tpointSetSrid, DataTypes.StringType); + spark.udf().register("tpointRound", tpointRound, DataTypes.StringType); + // Trajectory simplification + spark.udf().register("temporalSimplifyDp", temporalSimplifyDp, DataTypes.StringType); + spark.udf().register("temporalSimplifyMaxDist", temporalSimplifyMaxDist, DataTypes.StringType); + spark.udf().register("temporalSimplifyMinDist", temporalSimplifyMinDist, DataTypes.StringType); + spark.udf().register("temporalSimplifyMinTdelta", temporalSimplifyMinTdelta, DataTypes.StringType); + spark.udf().register("temporalTPrecision", temporalTPrecision, DataTypes.StringType); + // Temporal sampling + spark.udf().register("temporalTSample", temporalTSample, DataTypes.StringType); + // Trajectory extraction + spark.udf().register("tpointTrajectory", tpointTrajectory, DataTypes.StringType); + // floatset transforms + spark.udf().register("floatsetCeil", floatsetCeil, DataTypes.StringType); + spark.udf().register("floatsetFloor", floatsetFloor, DataTypes.StringType); + spark.udf().register("floatsetDegrees", floatsetDegrees, DataTypes.StringType); + spark.udf().register("floatsetRadians", floatsetRadians, DataTypes.StringType); + // textset case normalization + spark.udf().register("textsetLower", textsetLower, DataTypes.StringType); + spark.udf().register("textsetUpper", textsetUpper, DataTypes.StringType); + spark.udf().register("textsetInitcap", textsetInitcap, DataTypes.StringType); + // intspan / floatspan shift-scale + spark.udf().register("intspanShiftScale", intspanShiftScale, DataTypes.StringType); + spark.udf().register("floatspanShiftScale", floatspanShiftScale, DataTypes.StringType); + // intspanset / floatspanset transforms + spark.udf().register("intspansetShiftScale", intspansetShiftScale, DataTypes.StringType); + spark.udf().register("floatspansetShiftScale", floatspansetShiftScale, DataTypes.StringType); + spark.udf().register("floatspansetCeil", floatspansetCeil, DataTypes.StringType); + spark.udf().register("floatspansetFloor", floatspansetFloor, DataTypes.StringType); + spark.udf().register("floatspansetRound", floatspansetRound, DataTypes.StringType); + spark.udf().register("intspansetToFloat", intspansetToFloat, DataTypes.StringType); + spark.udf().register("floatspansetToInt", floatspansetToInt, DataTypes.StringType); + + // MobilityDB SQL bare-name aliases for the simplify family + spark.udf().register("douglasPeuckerSimplify", temporalSimplifyDp, DataTypes.StringType); + spark.udf().register("maxDistSimplify", temporalSimplifyMaxDist, DataTypes.StringType); + spark.udf().register("minDistSimplify", temporalSimplifyMinDist, DataTypes.StringType); + spark.udf().register("minTimeDeltaSimplify", temporalSimplifyMinTdelta, DataTypes.StringType); + // MobilityDB SQL bare-name aliases for span/spanset type conversions + spark.udf().register("intspanset", floatspansetToInt, DataTypes.StringType); + spark.udf().register("floatspanset", intspansetToFloat, DataTypes.StringType); + // shiftScale alias — most common case is floatspan + spark.udf().register("shiftScale", floatspanShiftScale, DataTypes.StringType); + // tstzset ↔ dateset conversions + spark.udf().register("dateset", tstzsetToDateset, DataTypes.StringType); + spark.udf().register("tstzset", datesetToTstzset, DataTypes.StringType); + // span / spanset constructor aliases + // (range/multirange NOT registered — they wrap PG-specific types + // with no Spark equivalent; see feedback_pg_specific_types_oos memory) + spark.udf().register("span", temporalToTstzspan, DataTypes.StringType); + spark.udf().register("spanset", spanToSpanset, DataTypes.StringType); + } + + public static final UDF1 temporalToTstzspan = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.temporal_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.temporal_to_tstzspan(p); + if (r == null) return null; + try { return functions.span_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 spanToSpanset = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.span_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.span_to_spanset(p); + if (r == null) return null; + try { return functions.spanset_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 tstzsetToDateset = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.tstzset_to_dateset(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; + + public static final UDF1 datesetToTstzset = + hex -> { + if (hex == null) return null; + MeosThread.ensureReady(); + Pointer p = functions.set_from_hexwkb(hex); + if (p == null) return null; + try { + Pointer r = functions.dateset_to_tstzset(p); + if (r == null) return null; + try { return functions.set_as_hexwkb(r, (byte) 0); } + finally { MeosMemory.free(r); } + } finally { MeosMemory.free(p); } + }; +} diff --git a/src/main/java/org/mobilitydb/spark/udfs/TemporalUDFs.java b/src/main/java/org/mobilitydb/spark/udfs/TemporalUDFs.java new file mode 100644 index 00000000..9daa7af3 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/udfs/TemporalUDFs.java @@ -0,0 +1,46 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.udfs; + +import org.apache.spark.sql.SparkSession; +import org.mobilitydb.spark.geo.GeoUDFs; + +/** + * Convenience facade — registers all MobilitySpark UDFs in one call. + * + * Prefer {@link org.mobilitydb.spark.MobilitySparkSession#create(SparkSession)} + * which also initialises MEOS. Use this class only when MEOS is already + * initialised by another mechanism. + */ +public final class TemporalUDFs { + + private TemporalUDFs() {} + + public static void registerAll(SparkSession spark) { + org.mobilitydb.spark.temporal.TemporalUDFs.registerAll(spark); + GeoUDFs.registerAll(spark); + } +} diff --git a/src/main/java/org/mobiltydb/Main.java b/src/main/java/org/mobiltydb/Main.java deleted file mode 100644 index 4a080b4b..00000000 --- a/src/main/java/org/mobiltydb/Main.java +++ /dev/null @@ -1,56 +0,0 @@ -package org.mobiltydb; - -import org.apache.spark.sql.*; -import org.apache.spark.sql.types.DataTypes; -import org.mobiltydb.UDF.PowerUDF; -import org.mobiltydb.UDT.classes.TimestampWithValue; - -import static jmeos.functions.functions.meos_finalize; -import static jmeos.functions.functions.meos_initialize; - -public class Main { - public static void main(String[] args) { - SparkSession spark = SparkSession - .builder() - .master("local[*]") - .appName("Java Spark SQL basic example") - .getOrCreate(); - - meos_initialize("UTC"); - // Create an array of TGeomPointInst instances - TimestampWithValue[] pointsArray = new TimestampWithValue[]{ - new TimestampWithValue(java.sql.Timestamp.valueOf("2023-07-20 12:00:00"), 10.5), - new TimestampWithValue(java.sql.Timestamp.valueOf("2023-07-21 15:30:00"), 15.3), - new TimestampWithValue(java.sql.Timestamp.valueOf("2023-07-22 18:45:00"), 20.1) - }; - - spark.udf().register("power", new PowerUDF(), DataTypes.DoubleType); - - - // Convert the array to a Dataset - Dataset pointsDF = spark.createDataFrame(java.util.Arrays.asList(pointsArray), TimestampWithValue.class); - - // Show the DataFrame - pointsDF.show(); - - // Register the DataFrame as a temporary table - pointsDF.createOrReplaceTempView("pointsTable"); - - // Use Spark SQL query to calculate the Euclidean distance and create a new DataFrame - Dataset result = spark.sql( - "SELECT timestamp, power(value) AS distance FROM pointsTable" - ); - - // Show the resulting DataFrame - result.show(); - - // Perform some basic operations on the DataFrame - Dataset filteredPoints = pointsDF.filter("value > 15.0"); - filteredPoints.show(); - - meos_finalize(); - - // Stop the Spark session - spark.stop(); - } -} diff --git a/src/main/java/org/mobiltydb/UDF/PowerUDF.java b/src/main/java/org/mobiltydb/UDF/PowerUDF.java deleted file mode 100644 index 3e018006..00000000 --- a/src/main/java/org/mobiltydb/UDF/PowerUDF.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.mobiltydb.UDF; - -import org.apache.spark.sql.api.java.UDF1; - -public class PowerUDF implements UDF1 { - @Override - public Double call(Double point1) { - // Calculate the distance between the two TemporalPoint objects using their properties. - return Math.abs(point1*point1); - } -} diff --git a/src/main/java/org/mobiltydb/UDT/TimestampWithValueUDT.java b/src/main/java/org/mobiltydb/UDT/TimestampWithValueUDT.java deleted file mode 100644 index 6ec7cafe..00000000 --- a/src/main/java/org/mobiltydb/UDT/TimestampWithValueUDT.java +++ /dev/null @@ -1,43 +0,0 @@ -package org.mobiltydb.UDT; - -import org.apache.spark.sql.catalyst.InternalRow; -import org.apache.spark.sql.catalyst.expressions.GenericInternalRow; -import org.apache.spark.sql.types.*; -import org.mobiltydb.UDT.classes.TimestampWithValue; - - -public class TimestampWithValueUDT extends UserDefinedType { - - @Override - public StructType sqlType() { - // Define the schema of your TemporalPoint class here - return DataTypes.createStructType(new StructField[] { - DataTypes.createStructField("timestamp", DataTypes.TimestampType, false), - DataTypes.createStructField("value", DataTypes.DoubleType, false) - }); - } - - @Override - public TimestampWithValue deserialize(Object datum) { - if (datum instanceof InternalRow) { - InternalRow row = (InternalRow) datum; - Double value = row.getDouble(1); - java.sql.Timestamp timestamp = (java.sql.Timestamp) row.get(0, DataTypes.TimestampType); - return new TimestampWithValue(timestamp, value); - } - return null; - } - @Override - public Object serialize(TimestampWithValue point) { - if (point == null) { - return null; - } - // Convert your TemporalPoint instance to an InternalRow - return new GenericInternalRow(new Object[] {point.getTimestamp(), point.getValue()}); - } - - @Override - public Class userClass() { - return TimestampWithValue.class; - } -} \ No newline at end of file diff --git a/src/main/java/org/mobiltydb/UDT/classes/TimestampWithValue.java b/src/main/java/org/mobiltydb/UDT/classes/TimestampWithValue.java deleted file mode 100644 index ffd90615..00000000 --- a/src/main/java/org/mobiltydb/UDT/classes/TimestampWithValue.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.mobiltydb.UDT.classes; - - -import java.io.Serializable; -import java.sql.Timestamp; - -public class TimestampWithValue implements Serializable { - private Timestamp timestamp; - private double value; - - public TimestampWithValue(Timestamp timestamp, double value) { - this.timestamp = timestamp; - this.value = value; - } - - public Timestamp getTimestamp() { - return timestamp; - } - - public double getValue() { - return value; - } -} diff --git a/src/test/java/org/mobilitydb/spark/NativeMemoryLeakTest.java b/src/test/java/org/mobilitydb/spark/NativeMemoryLeakTest.java new file mode 100644 index 00000000..c992b565 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/NativeMemoryLeakTest.java @@ -0,0 +1,202 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.geo.GeoUDFs; +import org.mobilitydb.spark.temporal.AnalyticsUDFs; +import org.mobilitydb.spark.temporal.TemporalUDFs; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.IOException; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Validates that MeosMemory.free() prevents native heap accumulation. + * + * Each test calls a UDF 5 000 times after a warmup run, then asserts + * that VmRSS (process resident-set size from /proc/self/status) grew + * by less than 10 MB. This is the Java-binding equivalent of running + * MEOS's C smoke tests (geo_test.c, temporal_test.c, setspan_test.c) + * under {@code valgrind --leak-check=full}. + * + * Why VmRSS rather than the Java heap: MEOS allocates objects with the + * system malloc; the JNR-FFI Pointer wrappers are tiny Java objects — + * the underlying C memory is invisible to the garbage collector. + * VmRSS is the only observable that reflects native-heap growth. + * + * Threshold rationale: the 10 MB limit accommodates glibc arena + * fragmentation (~0.1 KB/call) plus the structural char* micro-leak + * from JNR-FFI String-returning bindings (~0.4 KB/call × 5 000 = 2 MB). + * Real Temporal* leaks (the Q02 OOM crash root cause) grow at ≥100 KB/call + * and would produce ≥500 MB growth — far above the 10 MB limit. + * + * Tests are Linux-only (reads /proc/self/status). On non-Linux the + * vmRssKb() helper returns -1 and the growth check is skipped. + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class NativeMemoryLeakTest { + + private static final int WARMUP_ITERS = 200; + private static final int TEST_ITERS = 5_000; + // 10 MB tolerates glibc fragmentation + JNR-FFI char* micro-leaks + // (~0.4 KB/call for hex strings that JMEOS returns as Java String without + // freeing the underlying C char*). Real Temporal* leaks grow at ≥100 KB/call + // (900 KB/call for full BerlinMOD trips) and would far exceed this limit. + private static final long MAX_GROWTH_KB = 10_240; + + private static String TRIP_HEX; + private static final String GEOM_WKT = "POINT(0.05 0.0)"; + private static final String PERIOD = "[2020-01-01 00:00:00+00, 2020-01-01 00:30:00+00]"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + meos_initialize_noexit_error_handler(); + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(0.1 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // Intentionally no @AfterAll meos_finalize: calling it in a surefire + // @AfterAll causes a JVM crash during shutdown hook execution. + + /** Read VmRSS from /proc/self/status in kB; returns -1 on non-Linux. */ + private static long vmRssKb() { + try (BufferedReader br = new BufferedReader(new FileReader("/proc/self/status"))) { + String line; + while ((line = br.readLine()) != null) { + if (line.startsWith("VmRSS:")) { + return Long.parseLong(line.split("\\s+")[1]); + } + } + } catch (IOException ignored) {} + return -1; + } + + private static void forceGc() { + System.gc(); + System.runFinalization(); + System.gc(); + } + + private static void assertNoLeak(long beforeKb, long afterKb, String udfName) { + if (beforeKb < 0 || afterKb < 0) return; // non-Linux: skip + long growthKb = afterKb - beforeKb; + assertTrue(growthKb < MAX_GROWTH_KB, + udfName + " native heap grew " + growthKb + " KB over " + TEST_ITERS + + " calls (limit " + MAX_GROWTH_KB + " KB); check MeosMemory.free() in UDF"); + } + + // ------------------------------------------------------------------ + // eIntersects — heaviest leaker in BerlinMOD Q02 before fix. + // Allocates: Temporal* + STBox* + GSERIALIZED* per call. + // ------------------------------------------------------------------ + @Test @Order(1) + void eIntersects_noNativeLeak() throws Exception { + for (int i = 0; i < WARMUP_ITERS; i++) + GeoUDFs.eIntersects.call(TRIP_HEX, GEOM_WKT); + forceGc(); + long before = vmRssKb(); + + for (int i = 0; i < TEST_ITERS; i++) + GeoUDFs.eIntersects.call(TRIP_HEX, GEOM_WKT); + forceGc(); + assertNoLeak(before, vmRssKb(), "eIntersects"); + } + + // ------------------------------------------------------------------ + // atTime(span) — used by BerlinMOD Q07. + // Allocates: Temporal* (input) + Span* + Temporal* (result) per call. + // ------------------------------------------------------------------ + @Test @Order(2) + void atTime_span_noNativeLeak() throws Exception { + for (int i = 0; i < WARMUP_ITERS; i++) + TemporalUDFs.atTime.call(TRIP_HEX, PERIOD); + forceGc(); + long before = vmRssKb(); + + for (int i = 0; i < TEST_ITERS; i++) + TemporalUDFs.atTime.call(TRIP_HEX, PERIOD); + forceGc(); + assertNoLeak(before, vmRssKb(), "atTime(span)"); + } + + // ------------------------------------------------------------------ + // tpointSpeed — used by BerlinMOD Q08. + // Allocates: Temporal* (input) + Temporal* (tfloat result) per call. + // ------------------------------------------------------------------ + @Test @Order(3) + void tpointSpeed_noNativeLeak() throws Exception { + for (int i = 0; i < WARMUP_ITERS; i++) + AnalyticsUDFs.tpointSpeed.call(TRIP_HEX); + forceGc(); + long before = vmRssKb(); + + for (int i = 0; i < TEST_ITERS; i++) + AnalyticsUDFs.tpointSpeed.call(TRIP_HEX); + forceGc(); + assertNoLeak(before, vmRssKb(), "tpointSpeed"); + } + + // ------------------------------------------------------------------ + // tpointLength — used by BerlinMOD QRT. + // Allocates: Temporal* per call; returns primitive double (no result ptr). + // ------------------------------------------------------------------ + @Test @Order(4) + void tpointLength_noNativeLeak() throws Exception { + for (int i = 0; i < WARMUP_ITERS; i++) + AnalyticsUDFs.tpointLength.call(TRIP_HEX); + forceGc(); + long before = vmRssKb(); + + for (int i = 0; i < TEST_ITERS; i++) + AnalyticsUDFs.tpointLength.call(TRIP_HEX); + forceGc(); + assertNoLeak(before, vmRssKb(), "tpointLength"); + } + + // ------------------------------------------------------------------ + // trajectory — used by BerlinMOD Q01. + // Allocates: Temporal* + GSERIALIZED* result per call. + // ------------------------------------------------------------------ + @Test @Order(5) + void trajectory_noNativeLeak() throws Exception { + for (int i = 0; i < WARMUP_ITERS; i++) + GeoUDFs.trajectory.call(TRIP_HEX); + forceGc(); + long before = vmRssKb(); + + for (int i = 0; i < TEST_ITERS; i++) + GeoUDFs.trajectory.call(TRIP_HEX); + forceGc(); + assertNoLeak(before, vmRssKb(), "trajectory"); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsExtTest.java new file mode 100644 index 00000000..42776a27 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsExtTest.java @@ -0,0 +1,223 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.ConstructorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for nearest approach distance (nadTgeoGeo, nadTgeoTgeo, + * nadTgeoStbox) and nearest approach instant (naiTgeoGeo, naiTgeoTgeo). + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class DistanceUDFsExtTest { + + private static String TRIP; + private static String STBOX; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Simple 2-instant trip: (0,0)→(4,0) + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, " + + "POINT(4.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + + // STBox covering (0,0)→(4,0) with a time span + STBOX = ConstructorUDFs.stbox.call( + "STBOX XT(((0,0),(4,0)),[2020-01-01 00:00:00+00,2020-01-01 01:00:00+00])"); + } + + // ------------------------------------------------------------------ + // nadTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(1) + void nadTgeoGeo_collocated_returns_zero() throws Exception { + // Trip lies on x-axis; POINT(2,0) is on the trajectory at mid-time. + Double d = DistanceUDFs.nadTgeoGeo.call(TRIP, "POINT(2 0)"); + assertNotNull(d, "NAD must be non-null"); + assertEquals(0.0, d, 1e-9, "NAD to collocated point must be 0"); + } + + @Test @Order(2) + void nadTgeoGeo_perpendicular_offset() throws Exception { + // POINT(2,3) is 3 units above the trajectory. + Double d = DistanceUDFs.nadTgeoGeo.call(TRIP, "POINT(2 3)"); + assertNotNull(d); + assertEquals(3.0, d, 1e-6, "NAD to point 3 units above must be 3"); + } + + @Test @Order(3) + void nadTgeoGeo_null_trip_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoGeo.call(null, "POINT(0 0)")); + } + + @Test @Order(4) + void nadTgeoGeo_null_geom_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoGeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // nadTgeoStbox + // ------------------------------------------------------------------ + + @Test @Order(5) + void nadTgeoStbox_overlapping_returns_zero() throws Exception { + Double d = DistanceUDFs.nadTgeoStbox.call(TRIP, STBOX); + assertNotNull(d, "NAD tgeo×stbox must be non-null"); + assertEquals(0.0, d, 1e-6, "overlapping trip/stbox must give NAD 0"); + } + + @Test @Order(6) + void nadTgeoStbox_null_trip_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoStbox.call(null, STBOX)); + } + + @Test @Order(7) + void nadTgeoStbox_null_stbox_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoStbox.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // nadTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(8) + void nadTgeoTgeo_same_trip_returns_zero() throws Exception { + Double d = DistanceUDFs.nadTgeoTgeo.call(TRIP, TRIP); + assertNotNull(d); + assertEquals(0.0, d, 1e-9, "NAD of a trip to itself must be 0"); + } + + @Test @Order(9) + void nadTgeoTgeo_null_trip1_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoTgeo.call(null, TRIP)); + } + + @Test @Order(10) + void nadTgeoTgeo_null_trip2_returns_null() throws Exception { + assertNull(DistanceUDFs.nadTgeoTgeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // naiTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(11) + void naiTgeoGeo_returns_nonnull_hex() throws Exception { + String r = DistanceUDFs.naiTgeoGeo.call(TRIP, "POINT(2 3)"); + assertNotNull(r, "NAI must return non-null hex-WKB TInstant"); + assertFalse(r.isBlank()); + assertTrue(r.matches("[0-9A-Fa-f]+"), "result must be hex-WKB"); + } + + @Test @Order(12) + void naiTgeoGeo_null_trip_returns_null() throws Exception { + assertNull(DistanceUDFs.naiTgeoGeo.call(null, "POINT(0 0)")); + } + + @Test @Order(13) + void naiTgeoGeo_null_geom_returns_null() throws Exception { + assertNull(DistanceUDFs.naiTgeoGeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // naiTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(14) + void naiTgeoTgeo_returns_nonnull_hex() throws Exception { + String r = DistanceUDFs.naiTgeoTgeo.call(TRIP, TRIP); + assertNotNull(r, "NAI tgeo×tgeo must return non-null hex-WKB TInstant"); + assertFalse(r.isBlank()); + assertTrue(r.matches("[0-9A-Fa-f]+"), "result must be hex-WKB"); + } + + @Test @Order(15) + void naiTgeoTgeo_null_trip1_returns_null() throws Exception { + assertNull(DistanceUDFs.naiTgeoTgeo.call(null, TRIP)); + } + + @Test @Order(16) + void naiTgeoTgeo_null_trip2_returns_null() throws Exception { + assertNull(DistanceUDFs.naiTgeoTgeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // shortestLineTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(17) + void shortestLineTgeoGeo_returns_wkt_geometry() throws Exception { + String r = DistanceUDFs.shortestLineTgeoGeo.call(TRIP, "POINT(2 3)"); + assertNotNull(r, "shortestLine must return non-null WKT"); + assertFalse(r.isBlank()); + assertTrue(r.toUpperCase().startsWith("LINESTRING") || r.toUpperCase().startsWith("POINT"), + "result must be WKT geometry"); + } + + @Test @Order(18) + void shortestLineTgeoGeo_null_trip_returns_null() throws Exception { + assertNull(DistanceUDFs.shortestLineTgeoGeo.call(null, "POINT(0 0)")); + } + + @Test @Order(19) + void shortestLineTgeoGeo_null_geom_returns_null() throws Exception { + assertNull(DistanceUDFs.shortestLineTgeoGeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // shortestLineTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(20) + void shortestLineTgeoTgeo_returns_wkt_geometry() throws Exception { + String r = DistanceUDFs.shortestLineTgeoTgeo.call(TRIP, TRIP); + assertNotNull(r, "shortestLine tgeo×tgeo must return non-null WKT"); + assertFalse(r.isBlank()); + assertTrue(r.toUpperCase().startsWith("LINESTRING") || r.toUpperCase().startsWith("POINT"), + "result must be WKT geometry"); + } + + @Test @Order(21) + void shortestLineTgeoTgeo_null_trip1_returns_null() throws Exception { + assertNull(DistanceUDFs.shortestLineTgeoTgeo.call(null, TRIP)); + } + + @Test @Order(22) + void shortestLineTgeoTgeo_null_trip2_returns_null() throws Exception { + assertNull(DistanceUDFs.shortestLineTgeoTgeo.call(TRIP, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsTest.java new file mode 100644 index 00000000..9787d473 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/DistanceUDFsTest.java @@ -0,0 +1,117 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for DistanceUDFs — temporal distance between tgeo/tnumber and + * fixed or temporal counterparts. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class DistanceUDFsTest { + + private static String TRIP; + private static String TRIP2; + private static String TFLOAT_SEQ; + private static String TINT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(1 1)@2020-01-01 00:00:00+00, POINT(4 5)@2020-01-01 01:00:00+00]"), + (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 5.0@2020-01-03]"), (byte) 0); + TINT_SEQ = temporal_as_hexwkb( + tint_in("[2@2020-01-01, 6@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Spatial distance + // ------------------------------------------------------------------ + + @Test @Order(1) + void tdistanceTgeoGeo_returns_tfloat() throws Exception { + String r = DistanceUDFs.tdistanceTgeoGeo.call(TRIP, "POINT(0 0)"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tdistanceTgeoTgeo_returns_tfloat() throws Exception { + String r = DistanceUDFs.tdistanceTgeoTgeo.call(TRIP, TRIP2); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Number distance + // ------------------------------------------------------------------ + + @Test @Order(3) + void tdistanceTfloatFloat_returns_tfloat() throws Exception { + String r = DistanceUDFs.tdistanceTfloatFloat.call(TFLOAT_SEQ, 3.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void tdistanceTintInt_returns_tint() throws Exception { + String r = DistanceUDFs.tdistanceTintInt.call(TINT_SEQ, 4); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tdistanceTnumberTnumber_returns_tfloat() throws Exception { + String r = DistanceUDFs.tdistanceTnumberTnumber.call(TFLOAT_SEQ, TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(6) + void null_input_returns_null() throws Exception { + assertNull(DistanceUDFs.tdistanceTgeoGeo.call(null, "POINT(0 0)")); + assertNull(DistanceUDFs.tdistanceTgeoTgeo.call(null, TRIP2)); + assertNull(DistanceUDFs.tdistanceTfloatFloat.call(null, 1.0)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt2Test.java new file mode 100644 index 00000000..1b5866e6 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt2Test.java @@ -0,0 +1,78 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for GeoAnalyticsUDFs.geoSame. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoAnalyticsUDFsExt2Test { + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + } + + @Test @Order(1) + void geoSame_identical_points_returns_true() throws Exception { + Boolean r = GeoAnalyticsUDFs.geoSame.call("POINT(1 2)", "POINT(1 2)"); + assertNotNull(r, "geoSame must return non-null for identical points"); + assertTrue(r, "identical geometries must be the same"); + } + + @Test @Order(2) + void geoSame_different_points_returns_false() throws Exception { + Boolean r = GeoAnalyticsUDFs.geoSame.call("POINT(1 2)", "POINT(3 4)"); + assertNotNull(r); + assertFalse(r, "different geometries must not be the same"); + } + + @Test @Order(3) + void geoSame_identical_polygons_returns_true() throws Exception { + String poly = "POLYGON((0 0,1 0,1 1,0 1,0 0))"; + Boolean r = GeoAnalyticsUDFs.geoSame.call(poly, poly); + assertNotNull(r); + assertTrue(r, "identical polygons must be the same"); + } + + @Test @Order(4) + void geoSame_null_first_returns_null() throws Exception { + assertNull(GeoAnalyticsUDFs.geoSame.call(null, "POINT(1 2)")); + } + + @Test @Order(5) + void geoSame_null_second_returns_null() throws Exception { + assertNull(GeoAnalyticsUDFs.geoSame.call("POINT(1 2)", null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt3Test.java new file mode 100644 index 00000000..b4510b40 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoAnalyticsUDFsExt3Test.java @@ -0,0 +1,114 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for tpoint spatial analytics UDFs: + * tpointConvexHull, tpointExpandSpace. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoAnalyticsUDFsExt3Test { + + private static String TRIP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, " + + "POINT(2.0 2.0)@2020-01-01 01:00:00+00, " + + "POINT(4.0 0.0)@2020-01-01 02:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tpointConvexHull + // ------------------------------------------------------------------ + + @Test @Order(1) + void tpointConvexHull_returns_nonnull() throws Exception { + String r = GeoAnalyticsUDFs.tpointConvexHull.call(TRIP); + assertNotNull(r, "tpointConvexHull must return non-null hex-EWKB for valid trip"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tpointConvexHull_result_is_parseable_hex() throws Exception { + String r = GeoAnalyticsUDFs.tpointConvexHull.call(TRIP); + assertNotNull(r); + // All hex characters — a valid hex-EWKB string has only hex digits. + assertTrue(r.matches("[0-9A-Fa-f]+"), "result must be a hex string"); + } + + @Test @Order(3) + void tpointConvexHull_null_trip_returns_null() throws Exception { + assertNull(GeoAnalyticsUDFs.tpointConvexHull.call(null)); + } + + // ------------------------------------------------------------------ + // tpointExpandSpace + // ------------------------------------------------------------------ + + @Test @Order(4) + void tpointExpandSpace_returns_nonnull() throws Exception { + String r = GeoAnalyticsUDFs.tpointExpandSpace.call(TRIP, 1.0); + assertNotNull(r, "tpointExpandSpace must return non-null hex-WKB STBOX"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tpointExpandSpace_result_is_parseable_hex() throws Exception { + String r = GeoAnalyticsUDFs.tpointExpandSpace.call(TRIP, 0.5); + assertNotNull(r); + assertTrue(r.matches("[0-9A-Fa-f]+"), "result must be a hex string"); + } + + @Test @Order(6) + void tpointExpandSpace_null_trip_returns_null() throws Exception { + assertNull(GeoAnalyticsUDFs.tpointExpandSpace.call(null, 1.0)); + } + + @Test @Order(7) + void tpointExpandSpace_null_distance_returns_null() throws Exception { + assertNull(GeoAnalyticsUDFs.tpointExpandSpace.call(TRIP, null)); + } + + @Test @Order(8) + void tpointExpandSpace_zero_distance_returns_nonnull() throws Exception { + String r = GeoAnalyticsUDFs.tpointExpandSpace.call(TRIP, 0.0); + assertNotNull(r, "zero expansion distance must still produce a valid STBOX"); + assertFalse(r.isBlank()); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt2Test.java new file mode 100644 index 00000000..a40ca3a3 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt2Test.java @@ -0,0 +1,207 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for GeoUDFs ever/always predicates: + * eDisjoint, eTouches, eCovers, eDisjointTgeoTgeo, eIntersectsTgeoTgeo, + * aIntersects, aDisjoint, aDwithin, eDwithinGeo, aDwithinGeo. + * + * Fixture: + * TRIP — linear from (0,0) to (1,0) in 1 hour + * TRIP2 — parallel trip (1,0)→(2,0), same time window + * REGION_ON_PATH — polygon covering part of trip + * REGION_FAR — polygon far from trip + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsExt2Test { + + private static String TRIP; + private static String TRIP2; + private static final String REGION_ON_PATH = "POLYGON((-0.1 -1, 0.6 -1, 0.6 1, -0.1 1, -0.1 -1))"; + private static final String REGION_FAR = "POLYGON((10 10, 11 10, 11 11, 10 11, 10 10))"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(1.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(1.0 0.0)@2020-01-01 00:00:00+00, POINT(2.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // eDisjoint + // ------------------------------------------------------------------ + + @Test @Order(1) + void eDisjoint_trip_with_far_region_returns_true() throws Exception { + assertTrue(GeoUDFs.eDisjoint.call(TRIP, REGION_FAR), + "Trip is always disjoint from far region — ever-disjoint must be true"); + } + + @Test @Order(2) + void eDisjoint_trip_with_on_path_region_returns_non_null() throws Exception { + // Trip starts inside the region and exits — ever-disjoint is true at the exit end. + // Just verify the UDF completes without exception and returns a Boolean. + Boolean r = GeoUDFs.eDisjoint.call(TRIP, REGION_ON_PATH); + assertNotNull(r); + } + + @Test @Order(3) + void eDisjoint_null_returns_null() throws Exception { + assertNull(GeoUDFs.eDisjoint.call(null, REGION_FAR)); + assertNull(GeoUDFs.eDisjoint.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // eTouches + // ------------------------------------------------------------------ + + @Test @Order(4) + void eTouches_returns_non_null_for_valid_inputs() throws Exception { + Boolean r = GeoUDFs.eTouches.call(TRIP, REGION_ON_PATH); + // Result is Boolean; just ensure no crash + assertTrue(r == null || r instanceof Boolean); + } + + @Test @Order(5) + void eTouches_null_returns_null() throws Exception { + assertNull(GeoUDFs.eTouches.call(null, REGION_ON_PATH)); + assertNull(GeoUDFs.eTouches.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // eCovers + // ------------------------------------------------------------------ + + @Test @Order(6) + void eCovers_returns_non_null_boolean() throws Exception { + // ecovers_tgeo_geo semantics: returns true if the moving object ever covers + // the static geometry at any instant. Just verify no exception and non-null. + Boolean r = GeoUDFs.eCovers.call(TRIP, REGION_ON_PATH); + assertNotNull(r); + } + + @Test @Order(7) + void eCovers_null_returns_null() throws Exception { + assertNull(GeoUDFs.eCovers.call(null, REGION_ON_PATH)); + } + + // ------------------------------------------------------------------ + // eDisjointTgeoTgeo / eIntersectsTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(8) + void eDisjointTgeoTgeo_non_overlapping_trips_returns_true() throws Exception { + assertTrue(GeoUDFs.eDisjointTgeoTgeo.call(TRIP, TRIP2) != null); + } + + @Test @Order(9) + void eIntersectsTgeoTgeo_same_trip_returns_true() throws Exception { + assertTrue(GeoUDFs.eIntersectsTgeoTgeo.call(TRIP, TRIP), + "A trip always intersects itself"); + } + + @Test @Order(10) + void eDisjointTgeoTgeo_null_returns_null() throws Exception { + assertNull(GeoUDFs.eDisjointTgeoTgeo.call(null, TRIP)); + assertNull(GeoUDFs.eIntersectsTgeoTgeo.call(null, TRIP)); + } + + // ------------------------------------------------------------------ + // aIntersects / aDisjoint + // ------------------------------------------------------------------ + + @Test @Order(11) + void aDisjoint_trip_with_far_region_returns_true() throws Exception { + assertTrue(GeoUDFs.aDisjoint.call(TRIP, REGION_FAR), + "Trip is always disjoint from far region"); + } + + @Test @Order(12) + void aIntersects_trip_with_far_region_returns_false() throws Exception { + assertFalse(GeoUDFs.aIntersects.call(TRIP, REGION_FAR), + "Trip never intersects the far region"); + } + + @Test @Order(13) + void aIntersects_aDisjoint_null_returns_null() throws Exception { + assertNull(GeoUDFs.aIntersects.call(null, REGION_FAR)); + assertNull(GeoUDFs.aDisjoint.call(null, REGION_FAR)); + } + + // ------------------------------------------------------------------ + // aDwithin / eDwithinGeo / aDwithinGeo + // ------------------------------------------------------------------ + + @Test @Order(14) + void aDwithin_same_trip_with_large_dist_returns_true() throws Exception { + assertTrue(GeoUDFs.aDwithin.call(TRIP, TRIP, 1.0), + "A trip is always within distance 1.0 of itself"); + } + + @Test @Order(15) + void aDwithin_null_returns_null() throws Exception { + assertNull(GeoUDFs.aDwithin.call(null, TRIP, 1.0)); + assertNull(GeoUDFs.aDwithin.call(TRIP, null, 1.0)); + assertNull(GeoUDFs.aDwithin.call(TRIP, TRIP, null)); + } + + @Test @Order(16) + void eDwithinGeo_trip_within_large_radius_of_nearby_polygon_returns_true() throws Exception { + assertTrue(GeoUDFs.eDwithinGeo.call(TRIP, REGION_ON_PATH, 100.0), + "Trip is within 100 units of nearby polygon"); + } + + @Test @Order(17) + void eDwithinGeo_null_returns_null() throws Exception { + assertNull(GeoUDFs.eDwithinGeo.call(null, REGION_ON_PATH, 1.0)); + } + + @Test @Order(18) + void aDwithinGeo_trip_far_from_far_region_large_radius_returns_true() throws Exception { + Boolean r = GeoUDFs.aDwithinGeo.call(TRIP, REGION_FAR, 1000.0); + assertNotNull(r); + assertTrue(r, "Trip should be within 1000 units of far region"); + } + + @Test @Order(19) + void aDwithinGeo_null_returns_null() throws Exception { + assertNull(GeoUDFs.aDwithinGeo.call(null, REGION_FAR, 1.0)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt3Test.java new file mode 100644 index 00000000..c9643564 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt3Test.java @@ -0,0 +1,157 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for geo I/O UDFs: + * geoAsEwkt, geoAsGeojson, geoFromGeojson. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsExt3Test { + + private static final String POINT_WKT = "POINT(4.35 50.85)"; + private static final String POLYGON_WKT = "POLYGON((0 0,1 0,1 1,0 1,0 0))"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + } + + // ------------------------------------------------------------------ + // geoAsEwkt + // ------------------------------------------------------------------ + + @Test @Order(1) + void geoAsEwkt_point_returns_nonnull() throws Exception { + String r = GeoUDFs.geoAsEwkt.call(POINT_WKT, 6); + assertNotNull(r, "geoAsEwkt must return non-null for a valid WKT point"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void geoAsEwkt_point_contains_keyword() throws Exception { + String r = GeoUDFs.geoAsEwkt.call(POINT_WKT, 6); + assertNotNull(r); + assertTrue(r.toUpperCase().contains("POINT"), "EWKT must contain POINT keyword"); + } + + @Test @Order(3) + void geoAsEwkt_polygon_returns_nonnull() throws Exception { + String r = GeoUDFs.geoAsEwkt.call(POLYGON_WKT, 6); + assertNotNull(r, "geoAsEwkt must return non-null for a polygon"); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void geoAsEwkt_null_wkt_returns_null() throws Exception { + assertNull(GeoUDFs.geoAsEwkt.call(null, 6)); + } + + @Test @Order(5) + void geoAsEwkt_null_precision_uses_default() throws Exception { + String r = GeoUDFs.geoAsEwkt.call(POINT_WKT, null); + assertNotNull(r, "null precision must fall back to default (15)"); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // geoAsGeojson + // ------------------------------------------------------------------ + + @Test @Order(6) + void geoAsGeojson_point_returns_nonnull() throws Exception { + String r = GeoUDFs.geoAsGeojson.call(POINT_WKT, 0, 6); + assertNotNull(r, "geoAsGeojson must return non-null for a valid WKT point"); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void geoAsGeojson_point_contains_type_key() throws Exception { + String r = GeoUDFs.geoAsGeojson.call(POINT_WKT, 0, 6); + assertNotNull(r); + assertTrue(r.contains("\"type\""), "GeoJSON output must contain 'type' key"); + } + + @Test @Order(8) + void geoAsGeojson_polygon_returns_nonnull() throws Exception { + String r = GeoUDFs.geoAsGeojson.call(POLYGON_WKT, 0, 6); + assertNotNull(r, "geoAsGeojson must return non-null for a polygon"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void geoAsGeojson_null_returns_null() throws Exception { + assertNull(GeoUDFs.geoAsGeojson.call(null, 0, 6)); + } + + @Test @Order(10) + void geoAsGeojson_null_options_uses_default() throws Exception { + String r = GeoUDFs.geoAsGeojson.call(POINT_WKT, null, 6); + assertNotNull(r, "null options must fall back to default (0)"); + } + + // ------------------------------------------------------------------ + // geoFromGeojson + // ------------------------------------------------------------------ + + @Test @Order(11) + void geoFromGeojson_point_returns_wkt() throws Exception { + String geojson = "{\"type\":\"Point\",\"coordinates\":[4.35,50.85]}"; + String r = GeoUDFs.geoFromGeojson.call(geojson); + assertNotNull(r, "geoFromGeojson must return non-null for valid GeoJSON"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void geoFromGeojson_roundtrip_contains_point() throws Exception { + String geojson = "{\"type\":\"Point\",\"coordinates\":[1.0,2.0]}"; + String r = GeoUDFs.geoFromGeojson.call(geojson); + assertNotNull(r); + assertTrue(r.toUpperCase().contains("POINT"), "round-trip WKT must contain POINT"); + } + + @Test @Order(13) + void geoFromGeojson_null_returns_null() throws Exception { + assertNull(GeoUDFs.geoFromGeojson.call(null)); + } + + @Test @Order(14) + void geoAsGeojson_then_fromGeojson_roundtrip_consistent() throws Exception { + String geojson = GeoUDFs.geoAsGeojson.call(POINT_WKT, 0, 9); + assertNotNull(geojson); + String wkt = GeoUDFs.geoFromGeojson.call(geojson); + assertNotNull(wkt, "round-trip WKT→GeoJSON→WKT must not be null"); + assertTrue(wkt.toUpperCase().contains("POINT")); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt4Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt4Test.java new file mode 100644 index 00000000..e27c1fba --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt4Test.java @@ -0,0 +1,210 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for tpoint I/O and transformation UDFs: + * tpointAsText, tpointAsEWKT, tpointSRID, tpointSetSRID, tpointRound, + * tgeomToTgeog, tgeogToTgeom, tpointToStbox. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsExt4Test { + + private static String TRIP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(1.0 2.0)@2020-01-01 00:00:00+00, " + + "POINT(3.0 4.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tpointAsText + // ------------------------------------------------------------------ + + @Test @Order(1) + void tpointAsText_returns_nonnull() throws Exception { + String r = GeoUDFs.tpointAsText.call(TRIP, 6); + assertNotNull(r, "tpointAsText must return non-null for valid trip"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tpointAsText_contains_point_keyword() throws Exception { + String r = GeoUDFs.tpointAsText.call(TRIP, 6); + assertNotNull(r); + assertTrue(r.toUpperCase().contains("POINT"), "output must contain POINT keyword"); + } + + @Test @Order(3) + void tpointAsText_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointAsText.call(null, 6)); + } + + @Test @Order(4) + void tpointAsText_null_precision_uses_default() throws Exception { + String r = GeoUDFs.tpointAsText.call(TRIP, null); + assertNotNull(r, "null precision must fall back to 15"); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tpointAsEWKT + // ------------------------------------------------------------------ + + @Test @Order(5) + void tpointAsEWKT_returns_nonnull() throws Exception { + String r = GeoUDFs.tpointAsEWKT.call(TRIP, 6); + assertNotNull(r, "tpointAsEWKT must return non-null for valid trip"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tpointAsEWKT_contains_point_keyword() throws Exception { + String r = GeoUDFs.tpointAsEWKT.call(TRIP, 6); + assertNotNull(r); + assertTrue(r.toUpperCase().contains("POINT"), "EWKT must contain POINT keyword"); + } + + @Test @Order(7) + void tpointAsEWKT_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointAsEWKT.call(null, 6)); + } + + @Test @Order(8) + void tpointAsEWKT_null_precision_uses_default() throws Exception { + String r = GeoUDFs.tpointAsEWKT.call(TRIP, null); + assertNotNull(r, "null precision must fall back to 15"); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tpointSRID + // ------------------------------------------------------------------ + + @Test @Order(9) + void tpointSRID_returns_integer() throws Exception { + Integer r = GeoUDFs.tpointSRID.call(TRIP); + assertNotNull(r, "tpointSRID must return non-null for valid trip"); + } + + @Test @Order(10) + void tpointSRID_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointSRID.call(null)); + } + + // ------------------------------------------------------------------ + // tpointSetSRID + // ------------------------------------------------------------------ + + @Test @Order(11) + void tpointSetSRID_returns_nonnull() throws Exception { + String r = GeoUDFs.tpointSetSRID.call(TRIP, 4326); + assertNotNull(r, "tpointSetSRID must return non-null hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void tpointSetSRID_result_is_valid_temporal() throws Exception { + // ISO WKB (variant 0) does not embed SRID, so a hex-WKB round-trip resets + // SRID to 0. This test verifies the function completes without error and + // the result can be deserialized as a valid temporal. + String r = GeoUDFs.tpointSetSRID.call(TRIP, 4326); + assertNotNull(r); + String text = GeoUDFs.tpointAsText.call(r, 6); + assertNotNull(text, "result of tpointSetSRID must be a valid temporal"); + } + + @Test @Order(13) + void tpointSetSRID_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointSetSRID.call(null, 4326)); + } + + @Test @Order(14) + void tpointSetSRID_null_srid_returns_null() throws Exception { + assertNull(GeoUDFs.tpointSetSRID.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // tpointRound + // ------------------------------------------------------------------ + + @Test @Order(15) + void tpointRound_returns_nonnull() throws Exception { + String r = GeoUDFs.tpointRound.call(TRIP, 2); + assertNotNull(r, "tpointRound must return non-null hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(16) + void tpointRound_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointRound.call(null, 2)); + } + + @Test @Order(17) + void tpointRound_null_decimals_uses_default() throws Exception { + String r = GeoUDFs.tpointRound.call(TRIP, null); + assertNotNull(r, "null decimals must fall back to 6"); + assertFalse(r.isBlank()); + } + + @Test @Order(18) + void tpointRound_preserves_type() throws Exception { + String r = GeoUDFs.tpointRound.call(TRIP, 3); + assertNotNull(r); + // The result must be a valid temporal: tpointSRID must succeed. + Integer srid = GeoUDFs.tpointSRID.call(r); + assertNotNull(srid, "rounded trip must still be a valid tgeompoint"); + } + + // ------------------------------------------------------------------ + // tpointToStbox + // ------------------------------------------------------------------ + + @Test @Order(19) + void tpointToStbox_returns_nonnull() throws Exception { + String r = GeoUDFs.tpointToStbox.call(TRIP); + assertNotNull(r, "tpointToStbox must return non-null hex-WKB STBOX"); + assertFalse(r.isBlank()); + } + + @Test @Order(20) + void tpointToStbox_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointToStbox.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt5Test.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt5Test.java new file mode 100644 index 00000000..8c34486a --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExt5Test.java @@ -0,0 +1,85 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for tpointTransform. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsExt5Test { + + private static String TRIP_4326; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // SRID 4326: WGS-84 geographic coordinates + TRIP_4326 = temporal_as_hexwkb( + tgeompoint_in("SRID=4326;[POINT(4.35 50.85)@2020-01-01 00:00:00+00, " + + "POINT(4.40 50.90)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tpointTransform + // + // Note: tspatial_transform requires a spatial_ref_sys catalog loaded via + // meos_set_spatial_ref_sys_csv() (done inside MobilitySparkSession.create()). + // Unit tests that call meos_initialize() directly do not have the catalog, + // so transform calls return null gracefully (MEOS logs an error internally + // but does not crash). Tests here verify the null-handling contract and + // that the UDF does not throw any exception. + // ------------------------------------------------------------------ + + @Test @Order(1) + void tpointTransform_does_not_throw_without_srs_catalog() throws Exception { + // Without spatial_ref_sys.csv, MEOS returns null for any transform. + // Verify the UDF wraps this gracefully (null, not an exception). + String r = GeoUDFs.tpointTransform.call(TRIP_4326, 3857); + // r may be null — that is the correct contract when CRS is unavailable + assertTrue(r == null || !r.isBlank(), + "result must be null (no catalog) or a non-empty hex-WKB string"); + } + + @Test @Order(2) + void tpointTransform_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.tpointTransform.call(null, 3857)); + } + + @Test @Order(3) + void tpointTransform_null_srid_returns_null() throws Exception { + assertNull(GeoUDFs.tpointTransform.call(TRIP_4326, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExtTest.java new file mode 100644 index 00000000..51e38dd6 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsExtTest.java @@ -0,0 +1,163 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.AccessorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for GeoUDFs Phase 4 extensions — getX/Y/Z, cumulativeLength, + * stops, isSimple, shortestLine. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsExtTest { + + // Linear trip from (0,0) to (2,0) over 2 hours + private static String TRIP_HEX; + // Second trip offset in Y + private static String TRIP2_HEX; + // Self-intersecting trip (figure-8 approximation) + private static String TRIP_SELF_INTERSECTING; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(2 0)@2020-01-01 02:00:00+00]"), + (byte) 0); + TRIP2_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(3 1)@2020-01-01 00:00:00+00, POINT(3 2)@2020-01-01 02:00:00+00]"), + (byte) 0); + // A simple sequence (no self-intersection) + TRIP_SELF_INTERSECTING = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00, POINT(2 0)@2020-01-01 02:00:00+00]"), + (byte) 0); + } + + @Test @Order(1) + void getX_returns_tfloat_hex() throws Exception { + String x = GeoUDFs.getX.call(TRIP_HEX); + assertNotNull(x, "getX should return tfloat hex-WKB"); + assertFalse(x.isBlank()); + } + + @Test @Order(2) + void getX_start_value_is_zero() throws Exception { + String x = GeoUDFs.getX.call(TRIP_HEX); + assertNotNull(x); + // The start X coordinate should be 0.0 for POINT(0 0)@t1 + // Use tfloatStartValue from AccessorUDFs to check + Double sv = AccessorUDFs.tfloatStartValue.call(x); + assertNotNull(sv); + assertEquals(0.0, sv, 1e-9); + } + + @Test @Order(3) + void getY_returns_tfloat_hex() throws Exception { + String y = GeoUDFs.getY.call(TRIP_HEX); + assertNotNull(y, "getY should return tfloat hex-WKB"); + assertFalse(y.isBlank()); + } + + @Test @Order(4) + void getZ_2d_trip_returns_null() throws Exception { + // 2D tgeompoint has no Z component → MEOS returns null + assertNull(GeoUDFs.getZ.call(TRIP_HEX)); + } + + @Test @Order(5) + void getX_null_returns_null() throws Exception { + assertNull(GeoUDFs.getX.call(null)); + } + + @Test @Order(6) + void cumulativeLength_starts_at_zero() throws Exception { + String cl = GeoUDFs.cumulativeLength.call(TRIP_HEX); + assertNotNull(cl, "cumulativeLength should return a tfloat hex-WKB"); + // The start value of cumulative length for a linear trip should be 0.0 + Double sv = AccessorUDFs.tfloatStartValue.call(cl); + assertNotNull(sv); + assertEquals(0.0, sv, 1e-9); + } + + @Test @Order(7) + void cumulativeLength_null_returns_null() throws Exception { + assertNull(GeoUDFs.cumulativeLength.call(null)); + } + + @Test @Order(8) + void stops_returns_null_for_moving_trip() throws Exception { + // A perfectly linear trip has no stops — MEOS returns null for empty stops + // (rather than an empty sequence set) + String s = GeoUDFs.stops.call(TRIP_HEX, 0.001, "1 second"); + if (s != null) assertFalse(s.isBlank()); + } + + @Test @Order(9) + void stops_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.stops.call(null, 0.001, "1 second")); + } + + @Test @Order(10) + void isSimple_linear_trip_returns_true() throws Exception { + assertTrue(GeoUDFs.isSimple.call(TRIP_HEX), + "A straight linear trip should have no self-intersections"); + } + + @Test @Order(11) + void isSimple_null_returns_null() throws Exception { + assertNull(GeoUDFs.isSimple.call(null)); + } + + @Test @Order(12) + void shortestLine_between_parallel_trips_returns_wkt() throws Exception { + String wkt = GeoUDFs.shortestLine.call(TRIP_HEX, TRIP2_HEX); + assertNotNull(wkt, "shortestLine should return a WKT geometry"); + assertTrue(wkt.startsWith("POINT") || wkt.startsWith("LINESTRING"), + "Expected WKT geometry, got: " + wkt); + } + + @Test @Order(13) + void shortestLine_same_trip_returns_point() throws Exception { + String wkt = GeoUDFs.shortestLine.call(TRIP_HEX, TRIP_HEX); + assertNotNull(wkt); + assertTrue(wkt.startsWith("POINT") || wkt.startsWith("LINESTRING"), + "Expected WKT, got: " + wkt); + } + + @Test @Order(14) + void shortestLine_null_returns_null() throws Exception { + assertNull(GeoUDFs.shortestLine.call(null, TRIP_HEX)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/GeoUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsTest.java new file mode 100644 index 00000000..e1c5ba4f --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/GeoUDFsTest.java @@ -0,0 +1,114 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for GeoUDFs — spatial relations and distance on tgeompoint. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class GeoUDFsTest { + + private static String TRIP_HEX; + private static String TRIP2_HEX; + // Geometry passed as WKT text — eIntersects parses via geo_from_text internally + private static final String POINT_ON_PATH = "POINT(0.05 0.0)"; + private static final String POINT_FAR = "POINT(10.0 10.0)"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(0.1 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TRIP2_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.05 0.001)@2020-01-01 00:00:00+00, POINT(0.15 0.001)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + @AfterAll + static void finalizeMeos() { + meos_finalize(); + } + + @Test @Order(1) + void eIntersects_point_on_path_returns_true() throws Exception { + assertTrue(GeoUDFs.eIntersects.call(TRIP_HEX, POINT_ON_PATH)); + } + + @Test @Order(2) + void eIntersects_far_point_returns_false() throws Exception { + assertFalse(GeoUDFs.eIntersects.call(TRIP_HEX, POINT_FAR)); + } + + @Test @Order(3) + void eIntersects_null_trip_returns_null() throws Exception { + assertNull(GeoUDFs.eIntersects.call(null, POINT_ON_PATH)); + } + + @Test @Order(4) + void nearestApproachDistance_same_trip_is_zero() throws Exception { + Double d = GeoUDFs.nearestApproachDistance.call(TRIP_HEX, TRIP_HEX); + assertNotNull(d); + assertEquals(0.0, d, 1e-9); + } + + @Test @Order(5) + void nearestApproachDistance_parallel_trips() throws Exception { + Double d = GeoUDFs.nearestApproachDistance.call(TRIP_HEX, TRIP2_HEX); + assertNotNull(d); + assertTrue(d > 0.0 && d < 0.1, "Expected positive distance < 0.1, got " + d); + } + + @Test @Order(6) + void nearestApproachDistance_null_returns_null() throws Exception { + assertNull(GeoUDFs.nearestApproachDistance.call(null, TRIP_HEX)); + } + + @Test @Order(7) + void eDwithin_within_large_distance() throws Exception { + assertTrue(GeoUDFs.eDwithin.call(TRIP_HEX, TRIP2_HEX, 1.0)); + } + + @Test @Order(8) + void eDwithin_outside_tiny_distance() throws Exception { + assertFalse(GeoUDFs.eDwithin.call(TRIP_HEX, TRIP2_HEX, 1e-10)); + } + + @Test @Order(9) + void eDwithin_null_returns_null() throws Exception { + assertNull(GeoUDFs.eDwithin.call(null, TRIP_HEX, 1.0)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/STBoxUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/STBoxUDFsTest.java new file mode 100644 index 00000000..e209efcf --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/STBoxUDFsTest.java @@ -0,0 +1,224 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.ConstructorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for STBoxUDFs — STBox accessor and expansion operations. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * Input STBox values are produced via ConstructorUDFs.stbox (which handles + * the scratch-Pointer allocation required by stbox_as_hexwkb). + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class STBoxUDFsTest { + + // STBOX XT([-1,1],[-2,2],[2020-01-01,2020-01-02]) + private static String STBOX_XT; + // STBOX T([2020-01-01,2020-01-02]) — temporal-only box + private static String STBOX_T; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + STBOX_XT = ConstructorUDFs.stbox.call( + "STBOX XT(((-1,-2),(1,2)),[2020-01-01 00:00:00+00,2020-01-02 00:00:00+00])"); + STBOX_T = ConstructorUDFs.stbox.call( + "STBOX T([2020-01-01 00:00:00+00,2020-01-02 00:00:00+00])"); + } + + @Test @Order(1) + void stboxHasx_spatial_box_returns_true() throws Exception { + assertTrue(STBoxUDFs.stboxHasx.call(STBOX_XT)); + } + + @Test @Order(2) + void stboxHasx_temporal_only_box_returns_false() throws Exception { + assertFalse(STBoxUDFs.stboxHasx.call(STBOX_T)); + } + + @Test @Order(3) + void stboxHast_spatial_temporal_box_returns_true() throws Exception { + assertTrue(STBoxUDFs.stboxHast.call(STBOX_XT)); + } + + @Test @Order(4) + void stboxHasz_2d_box_returns_false() throws Exception { + assertFalse(STBoxUDFs.stboxHasz.call(STBOX_XT)); + } + + @Test @Order(5) + void stboxXmin_returns_minus_one() throws Exception { + Double v = STBoxUDFs.stboxXmin.call(STBOX_XT); + assertNotNull(v); + assertEquals(-1.0, v, 1e-9); + } + + @Test @Order(6) + void stboxXmax_returns_one() throws Exception { + Double v = STBoxUDFs.stboxXmax.call(STBOX_XT); + assertNotNull(v); + assertEquals(1.0, v, 1e-9); + } + + @Test @Order(7) + void stboxYmin_returns_minus_two() throws Exception { + Double v = STBoxUDFs.stboxYmin.call(STBOX_XT); + assertNotNull(v); + assertEquals(-2.0, v, 1e-9); + } + + @Test @Order(8) + void stboxYmax_returns_two() throws Exception { + Double v = STBoxUDFs.stboxYmax.call(STBOX_XT); + assertNotNull(v); + assertEquals(2.0, v, 1e-9); + } + + @Test @Order(9) + void stboxZmin_no_z_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxZmin.call(STBOX_XT)); + } + + @Test @Order(10) + void stboxTmin_returns_2020_01_01() throws Exception { + java.sql.Timestamp ts = STBoxUDFs.stboxTmin.call(STBOX_XT); + assertNotNull(ts, "stboxTmin should not be null for an XT box"); + assertTrue(ts.toInstant().toString().startsWith("2020-01-01"), + "Expected 2020-01-01, got: " + ts.toInstant()); + } + + @Test @Order(11) + void stboxTmax_returns_2020_01_02() throws Exception { + java.sql.Timestamp ts = STBoxUDFs.stboxTmax.call(STBOX_XT); + assertNotNull(ts); + assertTrue(ts.toInstant().toString().startsWith("2020-01-02"), + "Expected 2020-01-02, got: " + ts.toInstant()); + } + + @Test @Order(12) + void stboxTminInc_closed_lower_returns_true() throws Exception { + Boolean inc = STBoxUDFs.stboxTminInc.call(STBOX_XT); + assertNotNull(inc); + assertTrue(inc); + } + + @Test @Order(13) + void stboxTmaxInc_closed_upper_returns_true() throws Exception { + Boolean inc = STBoxUDFs.stboxTmaxInc.call(STBOX_XT); + assertNotNull(inc); + assertTrue(inc); + } + + @Test @Order(14) + void stboxSrid_zero_for_no_srid() throws Exception { + Integer srid = STBoxUDFs.stboxSrid.call(STBOX_XT); + assertNotNull(srid); + assertEquals(0, srid); + } + + @Test @Order(15) + void stboxXmin_null_input_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxXmin.call(null)); + } + + @Test @Order(16) + void stboxExpandSpace_xmax_grows() throws Exception { + String expanded = STBoxUDFs.stboxExpandSpace.call(STBOX_XT, 1.0); + assertNotNull(expanded, "stboxExpandSpace should return a hex-WKB"); + Double xmax = STBoxUDFs.stboxXmax.call(expanded); + assertNotNull(xmax); + assertTrue(xmax > 1.0, "Expanded Xmax should exceed original 1.0, got " + xmax); + } + + @Test @Order(17) + void stboxExpandTime_returns_non_null_hex() throws Exception { + String expanded = STBoxUDFs.stboxExpandTime.call(STBOX_XT, "1 day"); + assertNotNull(expanded, "stboxExpandTime should return a hex-WKB"); + assertFalse(expanded.isBlank()); + } + + @Test @Order(18) + void stboxArea_returns_positive() throws Exception { + Double area = STBoxUDFs.stboxArea.call(STBOX_XT); + assertNotNull(area); + assertTrue(area > 0, "Area of a 2×4 box should be positive"); + } + + @Test @Order(19) + void stboxPerimeter_returns_positive() throws Exception { + Double perim = STBoxUDFs.stboxPerimeter.call(STBOX_XT); + assertNotNull(perim); + assertTrue(perim > 0, "Perimeter of a non-degenerate box should be positive"); + } + + @Test @Order(20) + void stboxVolume_returns_value_for_2d_box() throws Exception { + Double vol = STBoxUDFs.stboxVolume.call(STBOX_XT); + assertNotNull(vol); + // MEOS returns -1.0 for a 2D box (no Z component) + assertTrue(vol == -1.0 || vol == 0.0, "Expected sentinel for 2D box, got: " + vol); + } + + @Test @Order(21) + void stboxIsGeodetic_cartesian_box_returns_false() throws Exception { + assertFalse(STBoxUDFs.stboxIsGeodetic.call(STBOX_XT)); + } + + @Test @Order(22) + void stboxToGeo_returns_wkt_polygon() throws Exception { + String wkt = STBoxUDFs.stboxToGeo.call(STBOX_XT); + assertNotNull(wkt); + assertTrue(wkt.startsWith("POLYGON") || wkt.startsWith("LINESTRING") || wkt.startsWith("POINT"), + "Expected geometry WKT, got: " + wkt); + } + + @Test @Order(23) + void stboxToTstzspan_returns_span_hex() throws Exception { + String spanHex = STBoxUDFs.stboxToTstzspan.call(STBOX_XT); + assertNotNull(spanHex); + assertFalse(spanHex.isBlank()); + } + + @Test @Order(24) + void stbox_analytics_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxArea.call(null)); + assertNull(STBoxUDFs.stboxPerimeter.call(null)); + assertNull(STBoxUDFs.stboxVolume.call(null)); + assertNull(STBoxUDFs.stboxIsGeodetic.call(null)); + assertNull(STBoxUDFs.stboxToGeo.call(null)); + assertNull(STBoxUDFs.stboxToTstzspan.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/StaticGeoUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/StaticGeoUDFsTest.java new file mode 100644 index 00000000..a09d0883 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/StaticGeoUDFsTest.java @@ -0,0 +1,197 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for StaticGeoUDFs: static geometry predicates, metrics, + * transforms, and line operations. + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class StaticGeoUDFsTest { + + private static final String POLY = "POLYGON((0 0,4 0,4 4,0 4,0 0))"; + private static final String POLY2 = "POLYGON((2 2,6 2,6 6,2 6,2 2))"; + private static final String POINT_INSIDE = "POINT(2 2)"; + private static final String POINT_OUTSIDE = "POINT(10 10)"; + private static final String LINE = "LINESTRING(0 0,10 0)"; + private static final String LINE2 = "LINESTRING(5 5,5 -5)"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + } + + // ------------------------------------------------------------------ + // Geometry predicates + // ------------------------------------------------------------------ + + @Test @Order(1) + void geomContains_polygon_contains_interior_point() throws Exception { + assertTrue(StaticGeoUDFs.geomContains.call(POLY, "POINT(1 1)")); + } + + @Test @Order(2) + void geomContains_polygon_does_not_contain_exterior_point() throws Exception { + assertFalse(StaticGeoUDFs.geomContains.call(POLY, POINT_OUTSIDE)); + } + + @Test @Order(3) + void geomIntersects_overlapping_polygons_is_true() throws Exception { + assertTrue(StaticGeoUDFs.geomIntersects.call(POLY, POLY2)); + } + + @Test @Order(4) + void geomDisjoint_non_overlapping_is_true() throws Exception { + String farPoly = "POLYGON((10 10,14 10,14 14,10 14,10 10))"; + assertTrue(StaticGeoUDFs.geomDisjoint.call(POLY, farPoly)); + } + + @Test @Order(5) + void geomTouches_crossing_lines_at_point() throws Exception { + // Two line segments that share only an endpoint — touches is true + String line1 = "LINESTRING(0 0,5 5)"; + String line2 = "LINESTRING(5 5,10 0)"; + assertTrue(StaticGeoUDFs.geomTouches.call(line1, line2)); + } + + @Test @Order(6) + void geomDwithin_close_points_is_true() throws Exception { + assertTrue(StaticGeoUDFs.geomDwithin.call("POINT(0 0)", "POINT(3 4)", 5.0001)); + } + + @Test @Order(7) + void geomDwithin_far_points_is_false() throws Exception { + assertFalse(StaticGeoUDFs.geomDwithin.call("POINT(0 0)", "POINT(100 100)", 1.0)); + } + + // ------------------------------------------------------------------ + // Geometry metrics + // ------------------------------------------------------------------ + + @Test @Order(8) + void geomDistance_between_points() throws Exception { + Double d = StaticGeoUDFs.geomDistance.call("POINT(0 0)", "POINT(3 4)"); + assertNotNull(d); + assertEquals(5.0, d, 1e-9); + } + + @Test @Order(9) + void geomLength_of_line() throws Exception { + Double len = StaticGeoUDFs.geomLength.call(LINE); + assertNotNull(len); + assertEquals(10.0, len, 1e-9); + } + + @Test @Order(10) + void geomPerimeter_of_square() throws Exception { + Double p = StaticGeoUDFs.geomPerimeter.call(POLY); + assertNotNull(p); + assertEquals(16.0, p, 1e-9); + } + + // ------------------------------------------------------------------ + // Geometry transforms + // ------------------------------------------------------------------ + + @Test @Order(11) + void geomCentroid_of_square_is_center() throws Exception { + String wkt = StaticGeoUDFs.geomCentroid.call(POLY); + assertNotNull(wkt); + assertTrue(wkt.startsWith("POINT"), "Expected POINT, got: " + wkt); + } + + @Test @Order(12) + void geomBoundary_of_polygon_is_ring() throws Exception { + String wkt = StaticGeoUDFs.geomBoundary.call(POLY); + assertNotNull(wkt); + assertTrue(wkt.startsWith("LINESTRING") || wkt.startsWith("MULTILINESTRING"), + "Expected LINESTRING, got: " + wkt); + } + + @Test @Order(13) + void geomDifference_returns_non_null() throws Exception { + String wkt = StaticGeoUDFs.geomDifference.call(POLY, POLY2); + assertNotNull(wkt); + assertFalse(wkt.isBlank()); + } + + @Test @Order(14) + void geoReverse_line_reverses_direction() throws Exception { + String wkt = StaticGeoUDFs.geoReverse.call(LINE); + assertNotNull(wkt); + assertTrue(wkt.startsWith("LINESTRING"), "Expected LINESTRING, got: " + wkt); + } + + @Test @Order(15) + void geoRound_reduces_precision() throws Exception { + String wkt = StaticGeoUDFs.geoRound.call("POINT(1.123456789 2.987654321)", 3); + assertNotNull(wkt); + assertTrue(wkt.startsWith("POINT"), "Expected POINT, got: " + wkt); + } + + // ------------------------------------------------------------------ + // Line functions + // ------------------------------------------------------------------ + + @Test @Order(16) + void lineInterpolatePoint_midpoint() throws Exception { + String wkt = StaticGeoUDFs.lineInterpolatePoint.call(LINE, 0.5); + assertNotNull(wkt); + assertTrue(wkt.startsWith("POINT"), "Expected POINT, got: " + wkt); + } + + @Test @Order(17) + void lineSubstring_half() throws Exception { + String wkt = StaticGeoUDFs.lineSubstring.call(LINE, 0.0, 0.5); + assertNotNull(wkt); + assertTrue(wkt.startsWith("LINESTRING"), "Expected LINESTRING, got: " + wkt); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(18) + void null_inputs_return_null() throws Exception { + assertNull(StaticGeoUDFs.geomContains.call(null, POLY)); + assertNull(StaticGeoUDFs.geomIntersects.call(POLY, null)); + assertNull(StaticGeoUDFs.geomDistance.call(null, "POINT(1 1)")); + assertNull(StaticGeoUDFs.geomLength.call(null)); + assertNull(StaticGeoUDFs.geomCentroid.call(null)); + assertNull(StaticGeoUDFs.geomBoundary.call(null)); + assertNull(StaticGeoUDFs.geoReverse.call(null)); + assertNull(StaticGeoUDFs.lineInterpolatePoint.call(null, 0.5)); + assertNull(StaticGeoUDFs.lineSubstring.call(null, 0.0, 0.5)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFsTest.java new file mode 100644 index 00000000..1aef5753 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/TPointSTBoxOpsUDFsTest.java @@ -0,0 +1,242 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.ConstructorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for cross-type STBox × TPoint positional and topological UDFs. + * + * Fixtures: + * TRIP — tgeopoint travelling from (0,0) to (4,0) + * STBOX_OVERLAP — STBOX covering (0,0)-(4,0) (overlaps trip) + * STBOX_RIGHT — STBOX at (10,0)-(14,0) (trip is left of this) + * + * MEOS function authority: meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TPointSTBoxOpsUDFsTest { + + private static String TRIP; + private static String STBOX_OVERLAP; + private static String STBOX_RIGHT; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, " + + "POINT(4.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + + STBOX_OVERLAP = ConstructorUDFs.stbox.call( + "STBOX XT(((0,0),(4,0)),[2020-01-01 00:00:00+00,2020-01-01 01:00:00+00])"); + + STBOX_RIGHT = ConstructorUDFs.stbox.call( + "STBOX XT(((10,0),(14,0)),[2020-01-01 00:00:00+00,2020-01-01 01:00:00+00])"); + } + + // ------------------------------------------------------------------ + // Null input guards (one representative test per direction) + // ------------------------------------------------------------------ + + @Test @Order(1) + void stboxLeftTpoint_null_stbox_returns_null() throws Exception { + assertNull(TPointSTBoxOpsUDFs.stboxLeftTpoint.call(null, TRIP)); + } + + @Test @Order(2) + void stboxLeftTpoint_null_tpoint_returns_null() throws Exception { + assertNull(TPointSTBoxOpsUDFs.stboxLeftTpoint.call(STBOX_OVERLAP, null)); + } + + @Test @Order(3) + void tpointLeftStbox_null_tpoint_returns_null() throws Exception { + assertNull(TPointSTBoxOpsUDFs.tpointLeftStbox.call(null, STBOX_OVERLAP)); + } + + @Test @Order(4) + void tpointLeftStbox_null_stbox_returns_null() throws Exception { + assertNull(TPointSTBoxOpsUDFs.tpointLeftStbox.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // Spatial direction predicates — stbox × tpoint + // ------------------------------------------------------------------ + + @Test @Order(5) + void stboxLeftTpoint_right_stbox_is_left_of_trip() throws Exception { + // STBOX_RIGHT is to the right of the trip origin area; + // trip (0-4) is to the LEFT of STBOX_RIGHT (10-14). + // So stboxLeftTpoint(STBOX_RIGHT, trip) → trip is NOT to the left of stbox + // Actually: left_stbox_tspatial means stbox is strictly LEFT of tspatial. + // STBOX_RIGHT (10-14) is NOT to the left of trip (0-4); trip is left of stbox. + Boolean r = TPointSTBoxOpsUDFs.stboxLeftTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + } + + @Test @Order(6) + void tpointLeftStbox_trip_is_left_of_right_stbox() throws Exception { + // trip (0-4) is strictly to the LEFT of STBOX_RIGHT (10-14) + Boolean r = TPointSTBoxOpsUDFs.tpointLeftStbox.call(TRIP, STBOX_RIGHT); + assertNotNull(r); + assertTrue(r, "trip (x∈[0,4]) must be left of stbox (x∈[10,14])"); + } + + @Test @Order(7) + void stboxRightTpoint_right_stbox_is_right_of_trip() throws Exception { + // STBOX_RIGHT (10-14) is strictly to the RIGHT of trip (0-4) + Boolean r = TPointSTBoxOpsUDFs.stboxRightTpoint.call(STBOX_RIGHT, TRIP); + assertNotNull(r); + assertTrue(r, "stbox (x∈[10,14]) must be right of trip (x∈[0,4])"); + } + + @Test @Order(8) + void tpointRightStbox_trip_not_right_of_right_stbox() throws Exception { + // trip (x∈[0,4]) is NOT to the right of STBOX_RIGHT (x∈[10,14]) + Boolean r = TPointSTBoxOpsUDFs.tpointRightStbox.call(TRIP, STBOX_RIGHT); + assertNotNull(r); + assertFalse(r, "trip (x∈[0,4]) must not be right of stbox (x∈[10,14])"); + } + + // ------------------------------------------------------------------ + // Topological predicates — stbox × tpoint + // ------------------------------------------------------------------ + + @Test @Order(9) + void stboxOverlapsTpoint_overlapping_returns_true() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.stboxOverlapsTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + assertTrue(r, "overlapping stbox/tpoint must give overlaps=true"); + } + + @Test @Order(10) + void stboxOverlapsTpoint_disjoint_returns_false() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.stboxOverlapsTpoint.call(STBOX_RIGHT, TRIP); + assertNotNull(r); + assertFalse(r, "non-overlapping stbox/tpoint must give overlaps=false"); + } + + @Test @Order(11) + void tpointOverlapsStbox_overlapping_returns_true() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.tpointOverlapsStbox.call(TRIP, STBOX_OVERLAP); + assertNotNull(r); + assertTrue(r, "trip inside stbox must give overlaps=true"); + } + + @Test @Order(12) + void stboxContainsTpoint_full_containment_returns_nonnull() throws Exception { + // Containment test: stbox at least as large as trip bounding box + Boolean r = TPointSTBoxOpsUDFs.stboxContainsTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + } + + @Test @Order(13) + void tpointContainedStbox_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.tpointContainedStbox.call(TRIP, STBOX_OVERLAP); + assertNotNull(r); + } + + @Test @Order(14) + void stboxSameTpoint_same_extent_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.stboxSameTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + } + + @Test @Order(15) + void tpointSameStbox_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.tpointSameStbox.call(TRIP, STBOX_OVERLAP); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // Temporal direction predicates + // ------------------------------------------------------------------ + + @Test @Order(16) + void stboxBeforeTpoint_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.stboxBeforeTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + } + + @Test @Order(17) + void tpointBeforeStbox_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.tpointBeforeStbox.call(TRIP, STBOX_OVERLAP); + assertNotNull(r); + } + + @Test @Order(18) + void stboxAfterTpoint_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.stboxAfterTpoint.call(STBOX_OVERLAP, TRIP); + assertNotNull(r); + } + + @Test @Order(19) + void tpointAfterStbox_returns_nonnull() throws Exception { + Boolean r = TPointSTBoxOpsUDFs.tpointAfterStbox.call(TRIP, STBOX_OVERLAP); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // Over-predicates (a representative sample) + // ------------------------------------------------------------------ + + @Test @Order(20) + void stboxOverleftTpoint_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.stboxOverleftTpoint.call(STBOX_OVERLAP, TRIP)); + } + + @Test @Order(21) + void stboxOverrightTpoint_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.stboxOverrightTpoint.call(STBOX_OVERLAP, TRIP)); + } + + @Test @Order(22) + void tpointOverleftStbox_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.tpointOverleftStbox.call(TRIP, STBOX_OVERLAP)); + } + + @Test @Order(23) + void tpointOverrightStbox_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.tpointOverrightStbox.call(TRIP, STBOX_OVERLAP)); + } + + @Test @Order(24) + void stboxAboveTpoint_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.stboxAboveTpoint.call(STBOX_OVERLAP, TRIP)); + } + + @Test @Order(25) + void tpointAboveStbox_returns_nonnull() throws Exception { + assertNotNull(TPointSTBoxOpsUDFs.tpointAboveStbox.call(TRIP, STBOX_OVERLAP)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsExtTest.java new file mode 100644 index 00000000..9cc3f629 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsExtTest.java @@ -0,0 +1,184 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TempSpatialRelsUDFs tgeo×tgeo and tgeo×geo variants: + * tDisjointTgeoTgeo, tIntersectsTgeoTgeo, tTouchesTogeoTgeo, + * tContainsTgeoGeo, tContainsTgeoTgeo, tCoversTgeoGeo, tDwithinTgeoGeo. + * + * Fixture: + * TRIP — linear from (0,0) to (1,0) over 1 hour + * TRIP2 — shifted trip: (0,0.5)→(1,0.5), same time window + * REGION_ON_PATH — polygon covering part of the trip path + * REGION_FAR — polygon far from the trip + * + * MEOS function authority: meos/include/meos_geo.h (072_tgeo_tempspatialrels) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TempSpatialRelsUDFsExtTest { + + private static String TRIP; + private static String TRIP2; + private static final String REGION_ON_PATH = "POLYGON((-0.1 -1, 0.6 -1, 0.6 1, -0.1 1, -0.1 -1))"; + private static final String REGION_FAR = "POLYGON((10 10, 11 10, 11 11, 10 11, 10 10))"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(1.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.5)@2020-01-01 00:00:00+00, POINT(1.0 0.5)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tDisjointTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(1) + void tDisjointTgeoTgeo_parallel_trips_returns_nonnull_tbool() throws Exception { + String r = TempSpatialRelsUDFs.tDisjointTgeoTgeo.call(TRIP, TRIP2); + assertNotNull(r, "tDisjointTgeoTgeo should return a tbool hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tDisjointTgeoTgeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tDisjointTgeoTgeo.call(null, TRIP)); + assertNull(TempSpatialRelsUDFs.tDisjointTgeoTgeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // tIntersectsTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(3) + void tIntersectsTgeoTgeo_same_trip_returns_nonnull_tbool() throws Exception { + String r = TempSpatialRelsUDFs.tIntersectsTgeoTgeo.call(TRIP, TRIP); + assertNotNull(r, "tIntersectsTgeoTgeo with same trip should return a tbool"); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void tIntersectsTgeoTgeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tIntersectsTgeoTgeo.call(null, TRIP)); + } + + // ------------------------------------------------------------------ + // tTouchesTogeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(5) + void tTouchesTogeoTgeo_returns_non_null_or_handles_gracefully() throws Exception { + // ttouches between point trajectories may return null for certain inputs; + // just verify no exception is thrown + String r = TempSpatialRelsUDFs.tTouchesTogeoTgeo.call(TRIP, TRIP2); + assertTrue(r == null || !r.isBlank(), "Result must be null or non-blank hex-WKB"); + } + + @Test @Order(6) + void tTouchesTogeoTgeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tTouchesTogeoTgeo.call(null, TRIP)); + } + + // ------------------------------------------------------------------ + // tContainsTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(7) + void tContainsTgeoGeo_returns_tbool_or_null() throws Exception { + // A point typically does not contain a polygon; result depends on semantics + String r = TempSpatialRelsUDFs.tContainsTgeoGeo.call(TRIP, REGION_FAR); + assertTrue(r == null || !r.isBlank(), "Result must be null or non-blank hex-WKB"); + } + + @Test @Order(8) + void tContainsTgeoGeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tContainsTgeoGeo.call(null, REGION_FAR)); + assertNull(TempSpatialRelsUDFs.tContainsTgeoGeo.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // tContainsTgeoTgeo + // ------------------------------------------------------------------ + + @Test @Order(9) + void tContainsTgeoTgeo_same_trip_returns_nonnull() throws Exception { + String r = TempSpatialRelsUDFs.tContainsTgeoTgeo.call(TRIP, TRIP); + assertNotNull(r, "tContainsTgeoTgeo with same trip should return a tbool"); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void tContainsTgeoTgeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tContainsTgeoTgeo.call(null, TRIP)); + } + + // ------------------------------------------------------------------ + // tCoversTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(11) + void tCoversTgeoGeo_returns_tbool_or_null() throws Exception { + String r = TempSpatialRelsUDFs.tCoversTgeoGeo.call(TRIP, REGION_FAR); + assertTrue(r == null || !r.isBlank(), "Result must be null or non-blank hex-WKB"); + } + + @Test @Order(12) + void tCoversTgeoGeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tCoversTgeoGeo.call(null, REGION_FAR)); + } + + // ------------------------------------------------------------------ + // tDwithinTgeoGeo + // ------------------------------------------------------------------ + + @Test @Order(13) + void tDwithinTgeoGeo_trip_with_nearby_point_returns_nonnull() throws Exception { + // tdwithin_tgeo_geo is defined for point geometries; polygon may return null. + // Use a point geometry close to the trip to ensure a valid result. + String r = TempSpatialRelsUDFs.tDwithinTgeoGeo.call(TRIP, "POINT(0.5 0.0)", 100.0); + assertNotNull(r, "tDwithinTgeoGeo with point geometry should return a tbool"); + assertFalse(r.isBlank()); + } + + @Test @Order(14) + void tDwithinTgeoGeo_null_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tDwithinTgeoGeo.call(null, REGION_ON_PATH, 1.0)); + assertNull(TempSpatialRelsUDFs.tDwithinTgeoGeo.call(TRIP, null, 1.0)); + assertNull(TempSpatialRelsUDFs.tDwithinTgeoGeo.call(TRIP, REGION_ON_PATH, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsTest.java b/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsTest.java new file mode 100644 index 00000000..cea31fc9 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/geo/TempSpatialRelsUDFsTest.java @@ -0,0 +1,129 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.geo; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TempSpatialRelsUDFs — tDisjoint, tIntersects, tTouches. + * + * Fixture: + * TRIP — tgeompoint moving along X axis from (0,0) to (1,0) + * REGION_ON_PATH — polygon enclosing the trip midpoint + * REGION_FAR — polygon far away from the trip + * + * MEOS function authority: meos/include/meos_geo.h (072_tgeo_tempspatialrels) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TempSpatialRelsUDFsTest { + + private static String TRIP; + private static final String REGION_ON_PATH = "POLYGON((0 -1, 1 -1, 1 1, 0 1, 0 -1))"; + private static final String REGION_FAR = "POLYGON((10 10, 11 10, 11 11, 10 11, 10 10))"; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(1.0 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tIntersects + // ------------------------------------------------------------------ + + @Test @Order(1) + void tIntersects_trip_with_region_on_path_returns_nonnull_tbool() throws Exception { + String r = TempSpatialRelsUDFs.tIntersects.call(TRIP, REGION_ON_PATH); + assertNotNull(r, "tIntersects should return a tbool hex-WKB when trip crosses region"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tIntersects_trip_with_far_region_returns_nonnull_tbool() throws Exception { + String r = TempSpatialRelsUDFs.tIntersects.call(TRIP, REGION_FAR); + assertNotNull(r); + } + + @Test @Order(3) + void tIntersects_null_trip_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tIntersects.call(null, REGION_ON_PATH)); + } + + @Test @Order(4) + void tIntersects_null_geom_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tIntersects.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // tDisjoint + // ------------------------------------------------------------------ + + @Test @Order(5) + void tDisjoint_trip_with_far_region_returns_nonnull_tbool() throws Exception { + String r = TempSpatialRelsUDFs.tDisjoint.call(TRIP, REGION_FAR); + assertNotNull(r, "tDisjoint should return a tbool hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tDisjoint_null_trip_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tDisjoint.call(null, REGION_FAR)); + } + + @Test @Order(7) + void tDisjoint_null_geom_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tDisjoint.call(TRIP, null)); + } + + // ------------------------------------------------------------------ + // tTouches + // ------------------------------------------------------------------ + + @Test @Order(8) + void tTouches_returns_nonnull_tbool_for_valid_inputs() throws Exception { + // tTouches tests the boundary; this just checks the UDF doesn't crash + String r = TempSpatialRelsUDFs.tTouches.call(TRIP, REGION_ON_PATH); + // Result may be null if MEOS raises an error for a non-boundary condition + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(9) + void tTouches_null_trip_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tTouches.call(null, REGION_ON_PATH)); + } + + @Test @Order(10) + void tTouches_null_geom_returns_null() throws Exception { + assertNull(TempSpatialRelsUDFs.tTouches.call(TRIP, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExt2Test.java new file mode 100644 index 00000000..9253e88c --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExt2Test.java @@ -0,0 +1,129 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new accessor UDFs: + * tintValueN (MoreAccessorUDFs), tnumberToSpan, tnumberToTbox (AccessorUDFs). + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class AccessorUDFsExt2Test { + + private static String TINT_SEQ; + private static String TFLOAT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb(tint_in("[3@2020-01-01, 7@2020-01-03]"), (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb(tfloat_in("[1.5@2020-01-01, 4.5@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tintValueN (MoreAccessorUDFs) + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintValueN_first_value_returns_correct() throws Exception { + Integer r = MoreAccessorUDFs.tintValueN.call(TINT_SEQ, 1); + assertNotNull(r, "First distinct value must be non-null"); + assertEquals(3, r.intValue()); + } + + @Test @Order(2) + void tintValueN_second_value_returns_correct() throws Exception { + Integer r = MoreAccessorUDFs.tintValueN.call(TINT_SEQ, 2); + assertNotNull(r, "Second distinct value must be non-null"); + assertEquals(7, r.intValue()); + } + + @Test @Order(3) + void tintValueN_out_of_range_returns_null() throws Exception { + Integer r = MoreAccessorUDFs.tintValueN.call(TINT_SEQ, 99); + assertNull(r, "Out-of-range index must return null"); + } + + @Test @Order(4) + void tintValueN_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tintValueN.call(null, 1)); + assertNull(MoreAccessorUDFs.tintValueN.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // tnumberToSpan (AccessorUDFs) + // ------------------------------------------------------------------ + + @Test @Order(5) + void tnumberToSpan_returns_nonnull_hexwkb() throws Exception { + String r = AccessorUDFs.tnumberToSpan.call(TINT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tnumberToSpan_tfloat_returns_nonnull_hexwkb() throws Exception { + String r = AccessorUDFs.tnumberToSpan.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void tnumberToSpan_null_returns_null() throws Exception { + assertNull(AccessorUDFs.tnumberToSpan.call(null)); + } + + // ------------------------------------------------------------------ + // tnumberToTbox (AccessorUDFs) + // ------------------------------------------------------------------ + + @Test @Order(8) + void tnumberToTbox_returns_nonnull_hexwkb() throws Exception { + String r = AccessorUDFs.tnumberToTbox.call(TINT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void tnumberToTbox_tfloat_returns_nonnull_hexwkb() throws Exception { + String r = AccessorUDFs.tnumberToTbox.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void tnumberToTbox_null_returns_null() throws Exception { + assertNull(AccessorUDFs.tnumberToTbox.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExtTest.java new file mode 100644 index 00000000..5844f8f6 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/AccessorUDFsExtTest.java @@ -0,0 +1,235 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.ConstructorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for extended AccessorUDFs — value restriction, spatio-temporal + * restriction, append operations, and value span accessor. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class AccessorUDFsExtTest { + + // tint sequence [1@t1, 3@t2, 2@t3] — min=1, max=3 + private static String TINT_SEQ; + // tstzspan for minusTime test + private static String TSTZSPAN_FIRST_HOUR; + // intset for atValues test + private static String INTSET_1_3; + // intspan tbox for tnumber restriction test (TBOXINT to match tint span type) + private static String TBOX; + // tgeompoint for stbox restriction test + private static String TRIP_HEX; + // stbox covering half the trip + private static String STBOX_HEX; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("{1@2020-01-01 00:00:00+00, 3@2020-01-01 01:00:00+00, 2@2020-01-01 02:00:00+00}"), + (byte) 0); + + TSTZSPAN_FIRST_HOUR = span_as_hexwkb( + tstzspan_in("[2020-01-01 00:00:00+00, 2020-01-01 01:00:00+00)"), (byte) 0); + + INTSET_1_3 = set_as_hexwkb(intset_in("{1, 3}"), (byte) 0); + + TBOX = ConstructorUDFs.tbox.call("TBOXINT XT([1,4],[2020-01-01 00:00:00+00, 2020-01-01 03:00:00+00])"); + + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(2 0)@2020-01-01 02:00:00+00]"), + (byte) 0); + + STBOX_HEX = ConstructorUDFs.stbox.call( + "STBOX XT(((0,0),(1,1)),[2020-01-01 00:00:00+00, 2020-01-01 02:00:00+00])"); + } + + // ------------------------------------------------------------------ + // atMin / atMax + // ------------------------------------------------------------------ + + @Test @Order(1) + void atMin_returns_instants_at_value_1() throws Exception { + String r = AccessorUDFs.atMin.call(TINT_SEQ); + assertNotNull(r, "atMin should return non-null for a valid tint"); + Integer sv = AccessorUDFs.tintStartValue.call(r); + assertNotNull(sv); + assertEquals(1, sv, "atMin start value should be the minimum (1)"); + } + + @Test @Order(2) + void atMax_returns_instants_at_value_3() throws Exception { + String r = AccessorUDFs.atMax.call(TINT_SEQ); + assertNotNull(r); + Integer sv = AccessorUDFs.tintStartValue.call(r); + assertNotNull(sv); + assertEquals(3, sv, "atMax start value should be the maximum (3)"); + } + + @Test @Order(3) + void atMin_null_returns_null() throws Exception { + assertNull(AccessorUDFs.atMin.call(null)); + } + + @Test @Order(4) + void atMax_null_returns_null() throws Exception { + assertNull(AccessorUDFs.atMax.call(null)); + } + + // ------------------------------------------------------------------ + // atValues + // ------------------------------------------------------------------ + + @Test @Order(5) + void atValues_restricts_to_values_1_and_3() throws Exception { + String r = AccessorUDFs.atValues.call(TINT_SEQ, INTSET_1_3); + assertNotNull(r, "atValues should return non-null when set intersects tint values"); + } + + @Test @Order(6) + void atValues_null_trip_returns_null() throws Exception { + assertNull(AccessorUDFs.atValues.call(null, INTSET_1_3)); + } + + // ------------------------------------------------------------------ + // minusTime + // ------------------------------------------------------------------ + + @Test @Order(7) + void minusTime_removes_first_hour() throws Exception { + String r = AccessorUDFs.minusTime.call(TINT_SEQ, TSTZSPAN_FIRST_HOUR); + assertNotNull(r, "minusTime should return remaining instants"); + } + + @Test @Order(8) + void minusTime_null_returns_null() throws Exception { + assertNull(AccessorUDFs.minusTime.call(null, TSTZSPAN_FIRST_HOUR)); + } + + // ------------------------------------------------------------------ + // minusMin / minusMax + // ------------------------------------------------------------------ + + @Test @Order(9) + void minusMin_excludes_value_1() throws Exception { + String r = AccessorUDFs.minusMin.call(TINT_SEQ); + assertNotNull(r, "minusMin should return instants not at minimum"); + } + + @Test @Order(10) + void minusMax_excludes_value_3() throws Exception { + String r = AccessorUDFs.minusMax.call(TINT_SEQ); + assertNotNull(r, "minusMax should return instants not at maximum"); + } + + // ------------------------------------------------------------------ + // atStbox / minusStbox + // ------------------------------------------------------------------ + + @Test @Order(11) + void atStbox_restricts_trip_to_box() throws Exception { + String r = AccessorUDFs.atStbox.call(TRIP_HEX, STBOX_HEX); + // May be null when no intersection — just verify no exception and non-blank if present + if (r != null) assertFalse(r.isBlank()); + } + + @Test @Order(12) + void atStbox_null_returns_null() throws Exception { + assertNull(AccessorUDFs.atStbox.call(null, STBOX_HEX)); + } + + @Test @Order(13) + void minusStbox_returns_part_outside_box() throws Exception { + String r = AccessorUDFs.minusStbox.call(TRIP_HEX, STBOX_HEX); + if (r != null) assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tnumberAtTbox / tnumberMinusTbox + // ------------------------------------------------------------------ + + @Test @Order(14) + void tnumberAtTbox_restricts_tint_to_tbox() throws Exception { + String r = AccessorUDFs.tnumberAtTbox.call(TINT_SEQ, TBOX); + assertNotNull(r, "tnumberAtTbox should return non-null when tbox covers tint range"); + } + + @Test @Order(15) + void tnumberAtTbox_null_returns_null() throws Exception { + assertNull(AccessorUDFs.tnumberAtTbox.call(null, TBOX)); + } + + @Test @Order(16) + void tnumberMinusTbox_returns_values_outside_tbox() throws Exception { + String r = AccessorUDFs.tnumberMinusTbox.call(TINT_SEQ, TBOX); + // Result can be null if all values are within the box + if (r != null) assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // appendInstant / appendSequence + // ------------------------------------------------------------------ + + @Test @Order(17) + void appendInstant_extends_sequence() throws Exception { + String instant = temporal_as_hexwkb( + tint_in("5@2020-01-01 03:00:00+00"), (byte) 0); + String r = AccessorUDFs.appendInstant.call(TINT_SEQ, instant); + assertNotNull(r, "appendInstant should return extended temporal"); + } + + @Test @Order(18) + void appendInstant_null_returns_null() throws Exception { + assertNull(AccessorUDFs.appendInstant.call(null, TINT_SEQ)); + } + + // ------------------------------------------------------------------ + // tnumberValuespans + // ------------------------------------------------------------------ + + @Test @Order(19) + void tnumberValuespans_returns_spanset_hex() throws Exception { + String ss = AccessorUDFs.tnumberValuespans.call(TINT_SEQ); + assertNotNull(ss, "tnumberValuespans should return a spanset hex-WKB"); + assertFalse(ss.isBlank()); + } + + @Test @Order(20) + void tnumberValuespans_null_returns_null() throws Exception { + assertNull(AccessorUDFs.tnumberValuespans.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/AggregateUDAFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/AggregateUDAFsTest.java new file mode 100644 index 00000000..d6242cbb --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/AggregateUDAFsTest.java @@ -0,0 +1,276 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for AggregateUDAFs — temporal aggregate functions exercised by + * driving each Aggregator's zero/reduce/merge/finish lifecycle directly, + * without a SparkSession. + * + * MEOS function authority: meos/include/meos.h (temporal aggregate transfns) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class AggregateUDAFsTest { + + private static String TRIP1; + private static String TRIP2; + private static String TINT1; + private static String TINT2; + private static String TFLOAT1; + private static String TFLOAT2; + private static String TBOOL_T; + private static String TBOOL_F; + private static String TTEXT1; + private static String TTEXT2; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP1 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 1)@2020-01-01 00:00:00+00, POINT(1 1)@2020-01-01 01:00:00+00]"), + (byte) 0); + TINT1 = temporal_as_hexwkb(tint_in("[1@2020-01-01, 2@2020-01-02]"), (byte) 0); + TINT2 = temporal_as_hexwkb(tint_in("[3@2020-01-01, 4@2020-01-02]"), (byte) 0); + TFLOAT1 = temporal_as_hexwkb(tfloat_in("[1.0@2020-01-01, 2.0@2020-01-02]"), (byte) 0); + TFLOAT2 = temporal_as_hexwkb(tfloat_in("[3.0@2020-01-01, 4.0@2020-01-02]"), (byte) 0); + TBOOL_T = temporal_as_hexwkb(tbool_in("[t@2020-01-01, t@2020-01-02]"), (byte) 0); + TBOOL_F = temporal_as_hexwkb(tbool_in("[f@2020-01-01, f@2020-01-02]"), (byte) 0); + TTEXT1 = temporal_as_hexwkb(ttext_in("[AAA@2020-01-01, BBB@2020-01-02]"), (byte) 0); + TTEXT2 = temporal_as_hexwkb(ttext_in("[CCC@2020-01-01, DDD@2020-01-02]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tCount + // ------------------------------------------------------------------ + + @Test @Order(1) + void tCount_two_overlapping_trips_returns_nonnull_tint() { + AggregateUDAFs.TCountFn agg = new AggregateUDAFs.TCountFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TRIP1); + buf = agg.reduce(buf, TRIP2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(2) + void tCount_single_trip_returns_nonnull() { + AggregateUDAFs.TCountFn agg = new AggregateUDAFs.TCountFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TRIP1); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(3) + void tCount_empty_input_returns_null() { + AggregateUDAFs.TCountFn agg = new AggregateUDAFs.TCountFn(); + assertNull(agg.finish(agg.zero())); + } + + // ------------------------------------------------------------------ + // tAnd / tOr + // ------------------------------------------------------------------ + + @Test @Order(4) + void tAnd_all_true_returns_nonnull_tbool() { + AggregateUDAFs.TAndFn agg = new AggregateUDAFs.TAndFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TBOOL_T); + buf = agg.reduce(buf, TBOOL_T); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(5) + void tOr_all_false_returns_nonnull_tbool() { + AggregateUDAFs.TOrFn agg = new AggregateUDAFs.TOrFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TBOOL_F); + buf = agg.reduce(buf, TBOOL_F); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // tIntMin / tIntMax / tIntSum + // ------------------------------------------------------------------ + + @Test @Order(6) + void tIntMin_returns_nonnull_tint() { + AggregateUDAFs.TIntMinFn agg = new AggregateUDAFs.TIntMinFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TINT1); + buf = agg.reduce(buf, TINT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(7) + void tIntMax_returns_nonnull_tint() { + AggregateUDAFs.TIntMaxFn agg = new AggregateUDAFs.TIntMaxFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TINT1); + buf = agg.reduce(buf, TINT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(8) + void tIntSum_returns_nonnull_tint() { + AggregateUDAFs.TIntSumFn agg = new AggregateUDAFs.TIntSumFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TINT1); + buf = agg.reduce(buf, TINT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // tFloatMin / tFloatMax / tFloatSum + // ------------------------------------------------------------------ + + @Test @Order(9) + void tFloatMin_returns_nonnull_tfloat() { + AggregateUDAFs.TFloatMinFn agg = new AggregateUDAFs.TFloatMinFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TFLOAT1); + buf = agg.reduce(buf, TFLOAT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(10) + void tFloatMax_returns_nonnull_tfloat() { + AggregateUDAFs.TFloatMaxFn agg = new AggregateUDAFs.TFloatMaxFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TFLOAT1); + buf = agg.reduce(buf, TFLOAT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(11) + void tFloatSum_returns_nonnull_tfloat() { + AggregateUDAFs.TFloatSumFn agg = new AggregateUDAFs.TFloatSumFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TFLOAT1); + buf = agg.reduce(buf, TFLOAT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // tTextMin / tTextMax + // ------------------------------------------------------------------ + + @Test @Order(12) + void tTextMin_returns_nonnull_ttext() { + AggregateUDAFs.TTextMinFn agg = new AggregateUDAFs.TTextMinFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TTEXT1); + buf = agg.reduce(buf, TTEXT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + @Test @Order(13) + void tTextMax_returns_nonnull_ttext() { + AggregateUDAFs.TTextMaxFn agg = new AggregateUDAFs.TTextMaxFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TTEXT1); + buf = agg.reduce(buf, TTEXT2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // tCentroid + // ------------------------------------------------------------------ + + @Test @Order(14) + void tCentroid_two_parallel_trips_returns_nonnull() { + AggregateUDAFs.TCentroidFn agg = new AggregateUDAFs.TCentroidFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TRIP1); + buf = agg.reduce(buf, TRIP2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // tExtent + // ------------------------------------------------------------------ + + @Test @Order(15) + void tExtent_returns_nonnull_stbox() { + AggregateUDAFs.TExtentFn agg = new AggregateUDAFs.TExtentFn(); + String buf = agg.zero(); + buf = agg.reduce(buf, TRIP1); + buf = agg.reduce(buf, TRIP2); + String result = agg.finish(buf); + assertNotNull(result); + assertFalse(result.isBlank()); + } + + // ------------------------------------------------------------------ + // merge + // ------------------------------------------------------------------ + + @Test @Order(16) + void merge_combines_two_buffers() { + AggregateUDAFs.TCountFn agg = new AggregateUDAFs.TCountFn(); + String b1 = agg.reduce(agg.zero(), TRIP1); + String b2 = agg.reduce(agg.zero(), TRIP2); + String merged = agg.merge(b1, b2); + String result = agg.finish(merged); + assertNotNull(result); + assertFalse(result.isBlank()); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/AnalyticsUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/AnalyticsUDFsExtTest.java new file mode 100644 index 00000000..bb671fb2 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/AnalyticsUDFsExtTest.java @@ -0,0 +1,110 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new AnalyticsUDFs and TransformUDFs additions: + * tpointCumulativeLength, tgeoTraversedArea, + * temporalShiftTime, temporalScaleTime. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class AnalyticsUDFsExtTest { + + private static String TRIP; + private static String TFLOAT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 5.0@2020-01-05]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tpointCumulativeLength + // ------------------------------------------------------------------ + + @Test @Order(1) + void tpointCumulativeLength_returns_nonnull() throws Exception { + String r = AnalyticsUDFs.tpointCumulativeLength.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tgeoTraversedArea + // ------------------------------------------------------------------ + + @Test @Order(2) + void tgeoTraversedArea_returns_wkt_or_null() throws Exception { + // tgeompoint (moving point) may return null from traversed_area; + // the function is primarily for polygon/body temporal types. + String r = AnalyticsUDFs.tgeoTraversedArea.call(TRIP); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // temporalShiftTime / temporalScaleTime + // ------------------------------------------------------------------ + + @Test @Order(3) + void temporalShiftTime_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalShiftTime.call(TFLOAT_SEQ, "1 day"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void temporalScaleTime_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalScaleTime.call(TFLOAT_SEQ, "10 days"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(5) + void null_input_returns_null() throws Exception { + assertNull(AnalyticsUDFs.tpointCumulativeLength.call(null)); + assertNull(AnalyticsUDFs.tgeoTraversedArea.call(null)); + assertNull(TransformUDFs.temporalShiftTime.call(null, "1 day")); + assertNull(TransformUDFs.temporalScaleTime.call(null, "1 day")); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsExtTest.java new file mode 100644 index 00000000..ce0010da --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsExtTest.java @@ -0,0 +1,125 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for temporal comparison operator UDFs: + * teqTemporalTemporal, tneTemporalTemporal, tltTemporalTemporal, + * tleTemporalTemporal, tgtTemporalTemporal, tgeTemporalTemporal. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class BoolOpsUDFsExtTest { + + private static String TFLOAT_A; + private static String TFLOAT_B; + private static String TBOOL_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TFLOAT_A = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 3.0@2020-01-03]"), (byte) 0); + TFLOAT_B = temporal_as_hexwkb( + tfloat_in("[2.0@2020-01-01, 2.0@2020-01-03]"), (byte) 0); + TBOOL_HEX = temporal_as_hexwkb( + tbool_in("[true@2020-01-01 00:00:00+00, false@2020-01-02 00:00:00+00]"), (byte) 0); + } + + @Test @Order(1) + void teqTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.teqTemporalTemporal.call(TFLOAT_A, TFLOAT_A); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tneTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.tneTemporalTemporal.call(TFLOAT_A, TFLOAT_B); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tltTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.tltTemporalTemporal.call(TFLOAT_A, TFLOAT_B); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void tleTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.tleTemporalTemporal.call(TFLOAT_A, TFLOAT_B); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tgtTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.tgtTemporalTemporal.call(TFLOAT_A, TFLOAT_B); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tgeTemporalTemporal_returns_tbool_hex() throws Exception { + String r = BoolOpsUDFs.tgeTemporalTemporal.call(TFLOAT_A, TFLOAT_B); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void null_input_returns_null() throws Exception { + assertNull(BoolOpsUDFs.teqTemporalTemporal.call(null, TFLOAT_A)); + assertNull(BoolOpsUDFs.tneTemporalTemporal.call(TFLOAT_A, null)); + assertNull(BoolOpsUDFs.tltTemporalTemporal.call(null, TFLOAT_B)); + assertNull(BoolOpsUDFs.tgeTemporalTemporal.call(null, null)); + } + + // ------------------------------------------------------------------ + // tnotTbool + // ------------------------------------------------------------------ + + @Test @Order(8) + void tnotTbool_returns_nonnull_hexwkb() throws Exception { + String r = BoolOpsUDFs.tnotTbool.call(TBOOL_HEX); + assertNotNull(r, "tnotTbool must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void tnotTbool_null_returns_null() throws Exception { + assertNull(BoolOpsUDFs.tnotTbool.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsTest.java new file mode 100644 index 00000000..99c5ca26 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/BoolOpsUDFsTest.java @@ -0,0 +1,121 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for BoolOpsUDFs — temporal AND/OR on tbool. + * + * MEOS function authority: meos/include/meos.h (028_tbool_boolops) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class BoolOpsUDFsTest { + + private static String TBOOL_TRUE; + private static String TBOOL_FALSE; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TBOOL_TRUE = temporal_as_hexwkb(tbool_in("t@2020-01-01"), (byte) 0); + TBOOL_FALSE = temporal_as_hexwkb(tbool_in("f@2020-01-01"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tand + // ------------------------------------------------------------------ + + @Test @Order(1) + void tandBool_true_and_true_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.tandBool.call(TBOOL_TRUE, true); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tandBool_true_and_false_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.tandBool.call(TBOOL_TRUE, false); + assertNotNull(r); + } + + @Test @Order(3) + void tandBoolTbool_false_and_true_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.tandBoolTbool.call(false, TBOOL_TRUE); + assertNotNull(r); + } + + @Test @Order(4) + void tandTboolTbool_true_and_false_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.tandTboolTbool.call(TBOOL_TRUE, TBOOL_FALSE); + assertNotNull(r); + } + + @Test @Order(5) + void tandBool_null_input_returns_null() throws Exception { + assertNull(BoolOpsUDFs.tandBool.call(null, true)); + assertNull(BoolOpsUDFs.tandBool.call(TBOOL_TRUE, null)); + } + + // ------------------------------------------------------------------ + // tor + // ------------------------------------------------------------------ + + @Test @Order(6) + void torBool_false_or_true_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.torBool.call(TBOOL_FALSE, true); + assertNotNull(r); + } + + @Test @Order(7) + void torBool_false_or_false_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.torBool.call(TBOOL_FALSE, false); + assertNotNull(r); + } + + @Test @Order(8) + void torBoolTbool_true_or_false_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.torBoolTbool.call(true, TBOOL_FALSE); + assertNotNull(r); + } + + @Test @Order(9) + void torTboolTbool_false_or_true_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.torTboolTbool.call(TBOOL_FALSE, TBOOL_TRUE); + assertNotNull(r); + } + + @Test @Order(10) + void torBool_null_input_returns_null() throws Exception { + assertNull(BoolOpsUDFs.torBool.call(null, true)); + assertNull(BoolOpsUDFs.torBool.call(TBOOL_FALSE, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/BucketUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/BucketUDFsTest.java new file mode 100644 index 00000000..4e5e9fe0 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/BucketUDFsTest.java @@ -0,0 +1,93 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class BucketUDFsTest { + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + } + + @Test @Order(1) + void floatBucket_aligns_to_origin() throws Exception { + // 7.3 with size 1.0, origin 0 → bucket [7.0, 8.0) → 7.0 + assertEquals(7.0, BucketUDFs.floatBucket.call(7.3, 1.0, 0.0), 1e-9); + } + + @Test @Order(2) + void floatBucket_negative_value() throws Exception { + // -0.5 with size 1.0, origin 0 → bucket [-1.0, 0.0) → -1.0 + assertEquals(-1.0, BucketUDFs.floatBucket.call(-0.5, 1.0, 0.0), 1e-9); + } + + @Test @Order(3) + void floatBucket_origin_offset() throws Exception { + // 7.3 with size 1.0, origin 0.5 → bucket [6.5, 7.5) → 6.5 + assertEquals(6.5, BucketUDFs.floatBucket.call(7.3, 1.0, 0.5), 1e-9); + } + + @Test @Order(4) + void floatBucket_null_value_returns_null() throws Exception { + assertNull(BucketUDFs.floatBucket.call(null, 1.0, 0.0)); + } + + @Test @Order(5) + void floatBucket_null_size_returns_null() throws Exception { + assertNull(BucketUDFs.floatBucket.call(7.3, null, 0.0)); + } + + @Test @Order(6) + void intBucket_basic() throws Exception { + // 17 with size 5, origin 0 → bucket [15, 20) → 15 + assertEquals(15, BucketUDFs.intBucket.call(17, 5, 0)); + } + + @Test @Order(7) + void intBucket_exact_boundary() throws Exception { + // 20 with size 5, origin 0 → bucket [20, 25) → 20 + assertEquals(20, BucketUDFs.intBucket.call(20, 5, 0)); + } + + @Test @Order(8) + void intBucket_negative() throws Exception { + assertEquals(-5, BucketUDFs.intBucket.call(-1, 5, 0)); + } + + @Test @Order(9) + void intBucket_null_returns_null() throws Exception { + assertNull(BucketUDFs.intBucket.call(null, 5, 0)); + assertNull(BucketUDFs.intBucket.call(17, null, 0)); + assertNull(BucketUDFs.intBucket.call(17, 5, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExt2Test.java new file mode 100644 index 00000000..fec1e215 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExt2Test.java @@ -0,0 +1,155 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for ConstructorUDFs constant-temporal constructors: + * tboolFromBaseTemp, tintFromBaseTemp, tfloatFromBaseTemp, ttextFromBaseTemp. + * + * Each creates a temporal value that is constant at the given scalar over the + * same time structure as a reference temporal. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class ConstructorUDFsExt2Test { + + private static String TINT_REF_HEX; + private static String TFLOAT_REF_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Reference temporals whose time structure will be reused + TINT_REF_HEX = temporal_as_hexwkb( + tint_in("[1@2020-01-01 00:00:00+00, 2@2020-01-02 00:00:00+00]"), (byte) 0); + TFLOAT_REF_HEX = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01 00:00:00+00, 2.0@2020-01-02 00:00:00+00]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tboolFromBaseTemp + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboolFromBaseTemp_returns_nonnull_hexwkb() throws Exception { + String r = ConstructorUDFs.tboolFromBaseTemp.call(true, TINT_REF_HEX); + assertNotNull(r, "tboolFromBaseTemp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tboolFromBaseTemp_false_returns_nonnull() throws Exception { + String r = ConstructorUDFs.tboolFromBaseTemp.call(false, TINT_REF_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tboolFromBaseTemp_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tboolFromBaseTemp.call(null, TINT_REF_HEX)); + assertNull(ConstructorUDFs.tboolFromBaseTemp.call(true, null)); + } + + // ------------------------------------------------------------------ + // tintFromBaseTemp + // ------------------------------------------------------------------ + + @Test @Order(4) + void tintFromBaseTemp_returns_nonnull_hexwkb() throws Exception { + String r = ConstructorUDFs.tintFromBaseTemp.call(42, TINT_REF_HEX); + assertNotNull(r, "tintFromBaseTemp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tintFromBaseTemp_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tintFromBaseTemp.call(null, TINT_REF_HEX)); + assertNull(ConstructorUDFs.tintFromBaseTemp.call(42, null)); + } + + // ------------------------------------------------------------------ + // tfloatFromBaseTemp + // ------------------------------------------------------------------ + + @Test @Order(6) + void tfloatFromBaseTemp_returns_nonnull_hexwkb() throws Exception { + String r = ConstructorUDFs.tfloatFromBaseTemp.call(3.14, TFLOAT_REF_HEX); + assertNotNull(r, "tfloatFromBaseTemp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void tfloatFromBaseTemp_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tfloatFromBaseTemp.call(null, TFLOAT_REF_HEX)); + assertNull(ConstructorUDFs.tfloatFromBaseTemp.call(3.14, null)); + } + + // ------------------------------------------------------------------ + // ttextFromBaseTemp + // ------------------------------------------------------------------ + + @Test @Order(8) + void ttextFromBaseTemp_returns_nonnull_hexwkb() throws Exception { + String r = ConstructorUDFs.ttextFromBaseTemp.call("hello", TINT_REF_HEX); + assertNotNull(r, "ttextFromBaseTemp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void ttextFromBaseTemp_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.ttextFromBaseTemp.call(null, TINT_REF_HEX)); + assertNull(ConstructorUDFs.ttextFromBaseTemp.call("hello", null)); + } + + // ------------------------------------------------------------------ + // tpointFromBaseTemp + // ------------------------------------------------------------------ + + @Test @Order(10) + void tpointFromBaseTemp_returns_nonnull_hexwkb() throws Exception { + String r = ConstructorUDFs.tpointFromBaseTemp.call("POINT(1.0 2.0)", TINT_REF_HEX); + assertNotNull(r, "tpointFromBaseTemp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(11) + void tpointFromBaseTemp_null_geo_returns_null() throws Exception { + assertNull(ConstructorUDFs.tpointFromBaseTemp.call(null, TINT_REF_HEX)); + } + + @Test @Order(12) + void tpointFromBaseTemp_null_ref_returns_null() throws Exception { + assertNull(ConstructorUDFs.tpointFromBaseTemp.call("POINT(1.0 2.0)", null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExtTest.java new file mode 100644 index 00000000..d714c077 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/ConstructorUDFsExtTest.java @@ -0,0 +1,181 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import jnr.ffi.Pointer; +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for ConstructorUDFs MFJSON round-trip constructors: + * tboolFromMfjson, tintFromMfjson, tfloatFromMfjson, ttextFromMfjson, + * tgeompointFromMfjson, tgeogpointFromMfjson. + * + * Each test converts a known temporal value to MFJSON then reconstructs it, + * verifying that the round-trip produces a valid non-null hex-WKB. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class ConstructorUDFsExtTest { + + private static String TBOOL_MFJSON; + private static String TINT_MFJSON; + private static String TFLOAT_MFJSON; + private static String TTEXT_MFJSON; + private static String TGEOMPOINT_MFJSON; + private static String TGEOGPOINT_MFJSON; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + Pointer tbool = tbool_in("[true@2020-01-01 00:00:00+00, false@2020-01-02 00:00:00+00]"); + TBOOL_MFJSON = temporal_as_mfjson(tbool, false, 0, 6, null); + + Pointer tint = tint_in("[1@2020-01-01 00:00:00+00, 3@2020-01-03 00:00:00+00]"); + TINT_MFJSON = temporal_as_mfjson(tint, false, 0, 6, null); + + Pointer tfloat = tfloat_in("[1.5@2020-01-01 00:00:00+00, 2.5@2020-01-03 00:00:00+00]"); + TFLOAT_MFJSON = temporal_as_mfjson(tfloat, false, 0, 6, null); + + Pointer ttext = ttext_in("[hello@2020-01-01 00:00:00+00, world@2020-01-02 00:00:00+00]"); + TTEXT_MFJSON = temporal_as_mfjson(ttext, false, 0, 6, null); + + Pointer tgeompoint = tgeompoint_in( + "[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00]"); + TGEOMPOINT_MFJSON = temporal_as_mfjson(tgeompoint, false, 0, 6, null); + + Pointer tgeogpoint = tgeogpoint_in( + "[POINT(4.35 50.85)@2020-01-01 00:00:00+00, POINT(4.36 50.86)@2020-01-01 01:00:00+00]"); + TGEOGPOINT_MFJSON = temporal_as_mfjson(tgeogpoint, false, 0, 6, null); + } + + // ------------------------------------------------------------------ + // tboolFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboolFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TBOOL_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.tboolFromMfjson.call(TBOOL_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tboolFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tboolFromMfjson.call(null)); + } + + // ------------------------------------------------------------------ + // tintFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(3) + void tintFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TINT_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.tintFromMfjson.call(TINT_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void tintFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tintFromMfjson.call(null)); + } + + // ------------------------------------------------------------------ + // tfloatFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(5) + void tfloatFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TFLOAT_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.tfloatFromMfjson.call(TFLOAT_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tfloatFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tfloatFromMfjson.call(null)); + } + + // ------------------------------------------------------------------ + // ttextFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(7) + void ttextFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TTEXT_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.ttextFromMfjson.call(TTEXT_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(8) + void ttextFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.ttextFromMfjson.call(null)); + } + + // ------------------------------------------------------------------ + // tgeompointFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(9) + void tgeompointFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TGEOMPOINT_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.tgeompointFromMfjson.call(TGEOMPOINT_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void tgeompointFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tgeompointFromMfjson.call(null)); + } + + // ------------------------------------------------------------------ + // tgeogpointFromMfjson + // ------------------------------------------------------------------ + + @Test @Order(11) + void tgeogpointFromMfjson_round_trip_returns_nonnull() throws Exception { + assertNotNull(TGEOGPOINT_MFJSON, "MFJSON source must be non-null"); + String r = ConstructorUDFs.tgeogpointFromMfjson.call(TGEOGPOINT_MFJSON); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void tgeogpointFromMfjson_null_returns_null() throws Exception { + assertNull(ConstructorUDFs.tgeogpointFromMfjson.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MathUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/MathUDFsExtTest.java new file mode 100644 index 00000000..6268367a --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MathUDFsExtTest.java @@ -0,0 +1,142 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new MathUDFs — transcendental functions (exp, ln, log10) + * and tnumberTrend, plus new BoolOps/Predicate UDFs (tboolWhenTrue, + * tpointIsSimple). + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MathUDFsExtTest { + + private static String TFLOAT_SEQ; + private static String TINT_SEQ; + private static String TBOOL_SEQ; + private static String TRIP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 2.0@2020-01-02, 4.0@2020-01-04]"), (byte) 0); + TINT_SEQ = temporal_as_hexwkb( + tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TBOOL_SEQ = temporal_as_hexwkb( + tbool_in("[true@2020-01-01, false@2020-01-02, true@2020-01-03]"), (byte) 0); + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // Transcendental functions + // ------------------------------------------------------------------ + + @Test @Order(1) + void tfloatExp_returns_nonnull() throws Exception { + String r = MathUDFs.tfloatExp.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tfloatLn_returns_nonnull() throws Exception { + String r = MathUDFs.tfloatLn.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tfloatLog10_returns_nonnull() throws Exception { + String r = MathUDFs.tfloatLog10.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tnumberTrend + // ------------------------------------------------------------------ + + @Test @Order(4) + void tnumberTrend_tfloat_returns_nonnull() throws Exception { + String r = AnalyticsUDFs.tnumberTrend.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tnumberTrend_tint_returns_nonnull() throws Exception { + String r = AnalyticsUDFs.tnumberTrend.call(TINT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tboolWhenTrue + // ------------------------------------------------------------------ + + @Test @Order(6) + void tboolWhenTrue_returns_nonnull() throws Exception { + String r = BoolOpsUDFs.tboolWhenTrue.call(TBOOL_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tpointIsSimple + // ------------------------------------------------------------------ + + @Test @Order(7) + void tpointIsSimple_simple_trip() throws Exception { + Boolean r = PredicateUDFs.tpointIsSimple.call(TRIP); + assertNotNull(r); + assertTrue(r); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(8) + void null_input_returns_null() throws Exception { + assertNull(MathUDFs.tfloatExp.call(null)); + assertNull(MathUDFs.tfloatLn.call(null)); + assertNull(MathUDFs.tfloatLog10.call(null)); + assertNull(AnalyticsUDFs.tnumberTrend.call(null)); + assertNull(BoolOpsUDFs.tboolWhenTrue.call(null)); + assertNull(PredicateUDFs.tpointIsSimple.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MathUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/MathUDFsTest.java new file mode 100644 index 00000000..462b9517 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MathUDFsTest.java @@ -0,0 +1,192 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MathUDFs — tnumber arithmetic and unary analytics. + * + * MEOS function authority: meos/include/meos.h (026_tnumber_mathfuncs) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MathUDFsTest { + + private static String TINT_NEG; + private static String TINT_POS; + private static String TFLOAT_POS; + private static String TRIP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // tint with negative value at t1, positive at t2 + TINT_NEG = temporal_as_hexwkb(tint_in("[-5@2020-01-01, 3@2020-01-02]"), (byte) 0); + TINT_POS = temporal_as_hexwkb(tint_in("[2@2020-01-01, 4@2020-01-02]"), (byte) 0); + TFLOAT_POS = temporal_as_hexwkb(tfloat_in("[1.0@2020-01-01, 3.0@2020-01-02]"), (byte) 0); + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01, POINT(1 0)@2020-01-02]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Unary analytics + // ------------------------------------------------------------------ + + @Test @Order(1) + void tnumberAbs_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.tnumberAbs.call(TINT_NEG); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tnumberDeltaValue_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.tnumberDeltaValue.call(TINT_POS); + assertNotNull(r); + } + + @Test @Order(3) + void tnumberAngularDifference_returns_nonnull_or_null_for_step() throws Exception { + // tnumber_angular_difference may return null for step sequences; just check no exception + String r = MathUDFs.tnumberAngularDifference.call(TFLOAT_POS); + // result can be null for non-periodic sequences — no assertion on value + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(4) + void tpointAngularDifference_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.tpointAngularDifference.call(TRIP); + // May be null for sequences with only 2 instants (no angular change to compute) + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(5) + void tnumberAbs_null_returns_null() throws Exception { + assertNull(MathUDFs.tnumberAbs.call(null)); + } + + // ------------------------------------------------------------------ + // tint + scalar + // ------------------------------------------------------------------ + + @Test @Order(6) + void addTintInt_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.addTintInt.call(TINT_POS, 10); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void subTintInt_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.subTintInt.call(TINT_POS, 1); + assertNotNull(r); + } + + @Test @Order(8) + void multTintInt_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.multTintInt.call(TINT_POS, 3); + assertNotNull(r); + } + + @Test @Order(9) + void divTintInt_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.divTintInt.call(TINT_POS, 2); + assertNotNull(r); + } + + @Test @Order(10) + void addTintInt_null_input_returns_null() throws Exception { + assertNull(MathUDFs.addTintInt.call(null, 5)); + assertNull(MathUDFs.addTintInt.call(TINT_POS, null)); + } + + // ------------------------------------------------------------------ + // tfloat + scalar + // ------------------------------------------------------------------ + + @Test @Order(11) + void addTfloatFloat_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.addTfloatFloat.call(TFLOAT_POS, 0.5); + assertNotNull(r); + } + + @Test @Order(12) + void subTfloatFloat_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.subTfloatFloat.call(TFLOAT_POS, 0.5); + assertNotNull(r); + } + + @Test @Order(13) + void multTfloatFloat_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.multTfloatFloat.call(TFLOAT_POS, 2.0); + assertNotNull(r); + } + + @Test @Order(14) + void divTfloatFloat_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.divTfloatFloat.call(TFLOAT_POS, 2.0); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // tnumber + tnumber + // ------------------------------------------------------------------ + + @Test @Order(15) + void addTnumberTnumber_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.addTnumberTnumber.call(TINT_POS, TINT_NEG); + assertNotNull(r); + } + + @Test @Order(16) + void subTnumberTnumber_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.subTnumberTnumber.call(TINT_POS, TINT_NEG); + assertNotNull(r); + } + + @Test @Order(17) + void multTnumberTnumber_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.multTnumberTnumber.call(TINT_POS, TINT_POS); + assertNotNull(r); + } + + @Test @Order(18) + void divTnumberTnumber_returns_nonnull_hexwkb() throws Exception { + String r = MathUDFs.divTnumberTnumber.call(TINT_POS, TINT_POS); + assertNotNull(r); + } + + @Test @Order(19) + void addTnumberTnumber_null_returns_null() throws Exception { + assertNull(MathUDFs.addTnumberTnumber.call(null, TINT_POS)); + assertNull(MathUDFs.addTnumberTnumber.call(TINT_POS, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt2Test.java new file mode 100644 index 00000000..14db1e95 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt2Test.java @@ -0,0 +1,116 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs array-returning accessors: + * temporalTimestamps, tboolValues. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsExt2Test { + + private static String TINT_SEQ_HEX; + private static String TBOOL_SEQ_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ_HEX = temporal_as_hexwkb( + tint_in("[1@2020-01-01 00:00:00+00, 2@2020-01-02 00:00:00+00, 3@2020-01-03 00:00:00+00]"), + (byte) 0); + TBOOL_SEQ_HEX = temporal_as_hexwkb( + tbool_in("[true@2020-01-01 00:00:00+00, false@2020-01-02 00:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // temporalTimestamps + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalTimestamps_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.temporalTimestamps.call(TINT_SEQ_HEX); + assertNotNull(r, "temporalTimestamps must return non-null"); + assertFalse(r.isEmpty(), "List must not be empty for 3-instant tint sequence"); + } + + @Test @Order(2) + void temporalTimestamps_count_matches_instants() throws Exception { + List r = MoreAccessorUDFs.temporalTimestamps.call(TINT_SEQ_HEX); + assertNotNull(r); + assertEquals(3, r.size(), "3-instant sequence must yield 3 timestamps"); + } + + @Test @Order(3) + void temporalTimestamps_timestamps_are_ordered() throws Exception { + List r = MoreAccessorUDFs.temporalTimestamps.call(TINT_SEQ_HEX); + assertNotNull(r); + assertEquals(3, r.size()); + assertTrue(r.get(0).before(r.get(1)), "timestamps must be in ascending order"); + assertTrue(r.get(1).before(r.get(2))); + } + + @Test @Order(4) + void temporalTimestamps_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.temporalTimestamps.call(null)); + } + + // ------------------------------------------------------------------ + // tboolValues + // ------------------------------------------------------------------ + + @Test @Order(5) + void tboolValues_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.tboolValues.call(TBOOL_SEQ_HEX); + assertNotNull(r, "tboolValues must return non-null"); + assertFalse(r.isEmpty()); + } + + @Test @Order(6) + void tboolValues_contains_both_values() throws Exception { + List r = MoreAccessorUDFs.tboolValues.call(TBOOL_SEQ_HEX); + assertNotNull(r); + assertTrue(r.contains(Boolean.TRUE), "Must contain true (appears in sequence)"); + assertTrue(r.contains(Boolean.FALSE), "Must contain false (appears in sequence)"); + } + + @Test @Order(7) + void tboolValues_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tboolValues.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt3Test.java new file mode 100644 index 00000000..7c69f7a4 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt3Test.java @@ -0,0 +1,115 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs array-returning accessors: + * tintValues, tfloatValues. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsExt3Test { + + private static String TINT_SEQ_HEX; + private static String TFLOAT_SEQ_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ_HEX = temporal_as_hexwkb( + tint_in("Interp=Step;[1@2020-01-01 00:00:00+00, 2@2020-01-02 00:00:00+00, 3@2020-01-03 00:00:00+00]"), + (byte) 0); + TFLOAT_SEQ_HEX = temporal_as_hexwkb( + tfloat_in("Interp=Step;[1.5@2020-01-01 00:00:00+00, 2.5@2020-01-02 00:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tintValues + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintValues_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.tintValues.call(TINT_SEQ_HEX); + assertNotNull(r, "tintValues must return non-null"); + assertFalse(r.isEmpty()); + } + + @Test @Order(2) + void tintValues_contains_expected_values() throws Exception { + List r = MoreAccessorUDFs.tintValues.call(TINT_SEQ_HEX); + assertNotNull(r); + assertTrue(r.contains(1), "Must contain value 1"); + assertTrue(r.contains(2), "Must contain value 2"); + assertTrue(r.contains(3), "Must contain value 3"); + } + + @Test @Order(3) + void tintValues_count_matches_distinct_instants() throws Exception { + List r = MoreAccessorUDFs.tintValues.call(TINT_SEQ_HEX); + assertNotNull(r); + assertEquals(3, r.size(), "3-instant step tint must yield 3 distinct values"); + } + + @Test @Order(4) + void tintValues_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tintValues.call(null)); + } + + // ------------------------------------------------------------------ + // tfloatValues + // ------------------------------------------------------------------ + + @Test @Order(5) + void tfloatValues_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.tfloatValues.call(TFLOAT_SEQ_HEX); + assertNotNull(r, "tfloatValues must return non-null"); + assertFalse(r.isEmpty()); + } + + @Test @Order(6) + void tfloatValues_contains_expected_values() throws Exception { + List r = MoreAccessorUDFs.tfloatValues.call(TFLOAT_SEQ_HEX); + assertNotNull(r); + assertTrue(r.contains(1.5), "Must contain value 1.5"); + assertTrue(r.contains(2.5), "Must contain value 2.5"); + } + + @Test @Order(7) + void tfloatValues_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tfloatValues.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt4Test.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt4Test.java new file mode 100644 index 00000000..dc7cc0b5 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt4Test.java @@ -0,0 +1,144 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs temporal decomposition accessors: + * temporalInstants, temporalSequences, temporalSegments. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsExt4Test { + + /** 3-instant linear tint sequence. */ + private static String TINT_SEQ_HEX; + /** TSequenceSet: 2 disjoint sequences. */ + private static String TINT_SEQSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ_HEX = temporal_as_hexwkb( + tint_in("[1@2020-01-01 00:00:00+00, 2@2020-01-02 00:00:00+00, 3@2020-01-03 00:00:00+00]"), + (byte) 0); + TINT_SEQSET_HEX = temporal_as_hexwkb( + tint_in("{[1@2020-01-01 00:00:00+00, 2@2020-01-02 00:00:00+00]," + + "[5@2020-02-01 00:00:00+00, 7@2020-02-03 00:00:00+00]}"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // temporalInstants + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalInstants_seq_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.temporalInstants.call(TINT_SEQ_HEX); + assertNotNull(r, "temporalInstants must return non-null"); + assertFalse(r.isEmpty()); + } + + @Test @Order(2) + void temporalInstants_seq_count_matches_instants() throws Exception { + List r = MoreAccessorUDFs.temporalInstants.call(TINT_SEQ_HEX); + assertNotNull(r); + assertEquals(3, r.size(), "3-instant sequence must yield 3 instants"); + } + + @Test @Order(3) + void temporalInstants_elements_are_valid_hexwkb() throws Exception { + List r = MoreAccessorUDFs.temporalInstants.call(TINT_SEQ_HEX); + assertNotNull(r); + for (String elem : r) { + assertNotNull(elem, "Each element must be non-null"); + assertFalse(elem.isBlank(), "Each element must be a non-blank hex string"); + } + } + + @Test @Order(4) + void temporalInstants_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.temporalInstants.call(null)); + } + + // ------------------------------------------------------------------ + // temporalSequences + // ------------------------------------------------------------------ + + @Test @Order(5) + void temporalSequences_seqset_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.temporalSequences.call(TINT_SEQSET_HEX); + assertNotNull(r, "temporalSequences must return non-null for TSequenceSet"); + assertFalse(r.isEmpty()); + } + + @Test @Order(6) + void temporalSequences_seqset_count_matches_sequences() throws Exception { + List r = MoreAccessorUDFs.temporalSequences.call(TINT_SEQSET_HEX); + assertNotNull(r); + assertEquals(2, r.size(), "2-sequence set must yield 2 sequences"); + } + + @Test @Order(7) + void temporalSequences_elements_are_valid_hexwkb() throws Exception { + List r = MoreAccessorUDFs.temporalSequences.call(TINT_SEQSET_HEX); + assertNotNull(r); + for (String elem : r) { + assertNotNull(elem); + assertFalse(elem.isBlank()); + } + } + + @Test @Order(8) + void temporalSequences_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.temporalSequences.call(null)); + } + + // ------------------------------------------------------------------ + // temporalSegments + // ------------------------------------------------------------------ + + @Test @Order(9) + void temporalSegments_seq_returns_nonnull_list() throws Exception { + List r = MoreAccessorUDFs.temporalSegments.call(TINT_SEQ_HEX); + assertNotNull(r, "temporalSegments must return non-null"); + assertFalse(r.isEmpty()); + } + + @Test @Order(10) + void temporalSegments_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.temporalSegments.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt5Test.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt5Test.java new file mode 100644 index 00000000..1bc2491a --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExt5Test.java @@ -0,0 +1,95 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs.ttextValues. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsExt5Test { + + /** ttext sequence with two distinct values. */ + private static String TTEXT_SEQ_HEX; + /** ttext sequence with repeated value — distinct count = 1. */ + private static String TTEXT_CONST_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TTEXT_SEQ_HEX = temporal_as_hexwkb( + ttext_in("[hello@2020-01-01 00:00:00+00, world@2020-01-02 00:00:00+00]"), + (byte) 0); + TTEXT_CONST_HEX = temporal_as_hexwkb( + ttext_in("[hello@2020-01-01 00:00:00+00, hello@2020-01-03 00:00:00+00]"), + (byte) 0); + } + + @Test @Order(1) + void ttextValues_seq_returns_nonnull() throws Exception { + List vs = MoreAccessorUDFs.ttextValues.call(TTEXT_SEQ_HEX); + assertNotNull(vs, "ttextValues must return non-null for ttext sequence"); + } + + @Test @Order(2) + void ttextValues_seq_count_is_two() throws Exception { + List vs = MoreAccessorUDFs.ttextValues.call(TTEXT_SEQ_HEX); + assertNotNull(vs); + assertEquals(2, vs.size(), "two-value sequence must yield 2 distinct values"); + } + + @Test @Order(3) + void ttextValues_elements_are_non_blank() throws Exception { + List vs = MoreAccessorUDFs.ttextValues.call(TTEXT_SEQ_HEX); + assertNotNull(vs); + for (String s : vs) { + assertNotNull(s); + assertFalse(s.isBlank(), "each value string must be non-blank"); + } + } + + @Test @Order(4) + void ttextValues_constant_seq_returns_one_distinct_value() throws Exception { + List vs = MoreAccessorUDFs.ttextValues.call(TTEXT_CONST_HEX); + assertNotNull(vs); + assertEquals(1, vs.size(), "constant ttext must yield exactly 1 distinct value"); + } + + @Test @Order(5) + void ttextValues_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.ttextValues.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExtTest.java new file mode 100644 index 00000000..bd00f450 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsExtTest.java @@ -0,0 +1,171 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs value_at_timestamptz UDFs: + * tboolValueAtTimestamptz, tintValueAtTimestamptz, tfloatValueAtTimestamptz, + * ttextValueAtTimestamptz. + * + * Timestamps are created as Spark java.sql.Timestamp (Unix-epoch ms). + * The UDFs convert them to PG-epoch µs internally before calling MEOS. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsExtTest { + + private static String TBOOL_SEQ; + private static String TINT_SEQ; + private static String TFLOAT_SEQ; + private static String TTEXT_SEQ; + + // Timestamps inside the sequences (2020-01-01 00:00:00 UTC = Unix 1577836800 s) + private static Timestamp TS_START; + // Timestamp outside the sequences (2020-06-01 00:00:00 UTC = Unix 1590969600 s) + private static Timestamp TS_OUTSIDE; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TBOOL_SEQ = temporal_as_hexwkb( + tbool_in("Interp=Step;[true@2020-01-01 00:00:00+00, true@2020-01-03 00:00:00+00]"), + (byte) 0); + TINT_SEQ = temporal_as_hexwkb( + tint_in("Interp=Step;[7@2020-01-01 00:00:00+00, 7@2020-01-03 00:00:00+00]"), + (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01 00:00:00+00, 3.0@2020-01-03 00:00:00+00]"), + (byte) 0); + TTEXT_SEQ = temporal_as_hexwkb( + ttext_in("Interp=Step;[hello@2020-01-01 00:00:00+00, hello@2020-01-03 00:00:00+00]"), + (byte) 0); + + TS_START = new Timestamp(1577836800L * 1000L); // 2020-01-01 00:00:00 UTC + TS_OUTSIDE = new Timestamp(1590969600L * 1000L); // 2020-06-01 00:00:00 UTC + } + + // ------------------------------------------------------------------ + // tboolValueAtTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboolValueAtTimestamptz_at_start_returns_true() throws Exception { + Boolean r = MoreAccessorUDFs.tboolValueAtTimestamptz.call(TBOOL_SEQ, TS_START); + assertNotNull(r, "Value at start timestamp must be non-null"); + assertTrue(r, "tbool value at t0 must be true"); + } + + @Test @Order(2) + void tboolValueAtTimestamptz_outside_range_returns_null() throws Exception { + Boolean r = MoreAccessorUDFs.tboolValueAtTimestamptz.call(TBOOL_SEQ, TS_OUTSIDE); + assertNull(r, "Value outside sequence range must be null"); + } + + @Test @Order(3) + void tboolValueAtTimestamptz_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tboolValueAtTimestamptz.call(null, TS_START)); + assertNull(MoreAccessorUDFs.tboolValueAtTimestamptz.call(TBOOL_SEQ, null)); + } + + // ------------------------------------------------------------------ + // tintValueAtTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(4) + void tintValueAtTimestamptz_at_start_returns_correct_value() throws Exception { + Integer r = MoreAccessorUDFs.tintValueAtTimestamptz.call(TINT_SEQ, TS_START); + assertNotNull(r, "Value at start timestamp must be non-null"); + assertEquals(7, r.intValue(), "tint value at t0 must be 7"); + } + + @Test @Order(5) + void tintValueAtTimestamptz_outside_range_returns_null() throws Exception { + Integer r = MoreAccessorUDFs.tintValueAtTimestamptz.call(TINT_SEQ, TS_OUTSIDE); + assertNull(r, "Value outside sequence range must be null"); + } + + @Test @Order(6) + void tintValueAtTimestamptz_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tintValueAtTimestamptz.call(null, TS_START)); + assertNull(MoreAccessorUDFs.tintValueAtTimestamptz.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // tfloatValueAtTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(7) + void tfloatValueAtTimestamptz_at_start_returns_1_0() throws Exception { + Double r = MoreAccessorUDFs.tfloatValueAtTimestamptz.call(TFLOAT_SEQ, TS_START); + assertNotNull(r, "Value at start timestamp must be non-null"); + assertEquals(1.0, r, 1e-9, "tfloat value at t0 must be 1.0"); + } + + @Test @Order(8) + void tfloatValueAtTimestamptz_outside_range_returns_null() throws Exception { + Double r = MoreAccessorUDFs.tfloatValueAtTimestamptz.call(TFLOAT_SEQ, TS_OUTSIDE); + assertNull(r, "Value outside sequence range must be null"); + } + + @Test @Order(9) + void tfloatValueAtTimestamptz_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.tfloatValueAtTimestamptz.call(null, TS_START)); + assertNull(MoreAccessorUDFs.tfloatValueAtTimestamptz.call(TFLOAT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // ttextValueAtTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(10) + void ttextValueAtTimestamptz_at_start_returns_correct_value() throws Exception { + String r = MoreAccessorUDFs.ttextValueAtTimestamptz.call(TTEXT_SEQ, TS_START); + assertNotNull(r, "Value at start timestamp must be non-null"); + assertEquals("\"hello\"", r, "ttext value at t0 must be '\"hello\"'"); + } + + @Test @Order(11) + void ttextValueAtTimestamptz_outside_range_returns_null() throws Exception { + String r = MoreAccessorUDFs.ttextValueAtTimestamptz.call(TTEXT_SEQ, TS_OUTSIDE); + assertNull(r, "Value outside sequence range must be null"); + } + + @Test @Order(12) + void ttextValueAtTimestamptz_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.ttextValueAtTimestamptz.call(null, TS_START)); + assertNull(MoreAccessorUDFs.ttextValueAtTimestamptz.call(TTEXT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsTest.java new file mode 100644 index 00000000..8b2e342b --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/MoreAccessorUDFsTest.java @@ -0,0 +1,268 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for MoreAccessorUDFs — subtype, instant/sequence navigation, + * timestampN, inclusivity flags, duration, type-specific valueN accessors, + * and tpoint geometry accessors. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class MoreAccessorUDFsTest { + + /** TSequence with 3 instants — covers instant/sequence navigation. */ + private static String TRIP; + private static String TINT_SEQ; + private static String TBOOL_SEQ; + private static String TFLOAT_SEQ; + private static String TTEXT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00," + + " POINT(2 0)@2020-01-02 00:00:00+00]"), + (byte) 0); + TINT_SEQ = temporal_as_hexwkb(tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TBOOL_SEQ = temporal_as_hexwkb(tbool_in("[t@2020-01-01, t@2020-01-02, f@2020-01-03]"), (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb(tfloat_in("[1.5@2020-01-01, 3.5@2020-01-02]"), (byte) 0); + TTEXT_SEQ = temporal_as_hexwkb(ttext_in("[AAA@2020-01-01, ZZZ@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Subtype + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalSubtype_tsequence_returns_Sequence() throws Exception { + String r = MoreAccessorUDFs.temporalSubtype.call(TRIP); + assertNotNull(r); + assertTrue(r.contains("Sequence")); + } + + // ------------------------------------------------------------------ + // Instant navigation + // ------------------------------------------------------------------ + + @Test @Order(2) + void startInstant_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.startInstant.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void endInstant_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.endInstant.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void instantN_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.instantN.call(TRIP, 1); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Sequence navigation + // ------------------------------------------------------------------ + + @Test @Order(5) + void startSequence_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.startSequence.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void endSequence_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.endSequence.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void sequenceN_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.sequenceN.call(TRIP, 1); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Min/max instant + // ------------------------------------------------------------------ + + @Test @Order(8) + void minInstant_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.minInstant.call(TINT_SEQ); + assertNotNull(r); + } + + @Test @Order(9) + void maxInstant_returns_nonnull_hexwkb() throws Exception { + String r = MoreAccessorUDFs.maxInstant.call(TINT_SEQ); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // Timestamp accessors + // ------------------------------------------------------------------ + + @Test @Order(10) + void numTimestamps_returns_positive_int() throws Exception { + Integer r = MoreAccessorUDFs.numTimestamps.call(TRIP); + assertNotNull(r); + assertTrue(r >= 1); + } + + @Test @Order(11) + void timestampN_returns_nonnull_timestamp() throws Exception { + java.sql.Timestamp r = MoreAccessorUDFs.timestampN.call(TRIP, 1); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // Inclusivity flags + // ------------------------------------------------------------------ + + @Test @Order(12) + void lowerInc_returns_boolean() throws Exception { + Boolean r = MoreAccessorUDFs.lowerInc.call(TRIP); + assertNotNull(r); + } + + @Test @Order(13) + void upperInc_returns_boolean() throws Exception { + Boolean r = MoreAccessorUDFs.upperInc.call(TRIP); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // Duration + // ------------------------------------------------------------------ + + @Test @Order(14) + void duration_returns_nonnull_string() throws Exception { + String r = MoreAccessorUDFs.duration.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // tbool value accessor + // ------------------------------------------------------------------ + + @Test @Order(15) + void tboolValueN_returns_boolean() throws Exception { + Boolean r = MoreAccessorUDFs.tboolValueN.call(TBOOL_SEQ, 1); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // tfloat value accessor + // ------------------------------------------------------------------ + + @Test @Order(16) + void tfloatValueN_returns_double() throws Exception { + Double r = MoreAccessorUDFs.tfloatValueN.call(TFLOAT_SEQ, 1); + assertNotNull(r); + assertTrue(r >= 0.0); + } + + // ------------------------------------------------------------------ + // ttext value accessors + // ------------------------------------------------------------------ + + @Test @Order(17) + void ttextMinValue_returns_string() throws Exception { + String r = MoreAccessorUDFs.ttextMinValue.call(TTEXT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(18) + void ttextMaxValue_returns_string() throws Exception { + String r = MoreAccessorUDFs.ttextMaxValue.call(TTEXT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(19) + void ttextValueN_returns_string() throws Exception { + String r = MoreAccessorUDFs.ttextValueN.call(TTEXT_SEQ, 1); + assertNotNull(r); + } + + // ------------------------------------------------------------------ + // tpoint accessors + // ------------------------------------------------------------------ + + @Test @Order(20) + void tpointSrid_returns_int() throws Exception { + Integer r = MoreAccessorUDFs.tpointSrid.call(TRIP); + assertNotNull(r); + } + + @Test @Order(21) + void tpointValueN_returns_wkt() throws Exception { + String r = MoreAccessorUDFs.tpointValueN.call(TRIP, 1); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(22) + void tpointConvexHull_returns_wkt() throws Exception { + String r = MoreAccessorUDFs.tpointConvexHull.call(TRIP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(23) + void startInstant_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.startInstant.call(null)); + } + + @Test @Order(24) + void timestampN_null_returns_null() throws Exception { + assertNull(MoreAccessorUDFs.timestampN.call(null, 1)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/PosOpsUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/PosOpsUDFsTest.java new file mode 100644 index 00000000..24fe793c --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/PosOpsUDFsTest.java @@ -0,0 +1,224 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for PosOpsUDFs — temporal and spatial positional operators. + * + * Fixtures: + * TRIP_EARLY — tgeompoint January 2020 + * TRIP_LATE — tgeompoint July 2020 + * TINT_LOW — tint with values [1,3] + * TINT_HIGH — tint with values [10,20] + * TRIP_LEFT — tgeompoint with X in [0,1] + * TRIP_RIGHT — tgeompoint with X in [5,6] + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class PosOpsUDFsTest { + + private static String TRIP_EARLY; + private static String TRIP_LATE; + private static String TINT_LOW; + private static String TINT_HIGH; + private static String TRIP_LEFT; + private static String TRIP_RIGHT; + private static String SPAN_EARLY; + private static String SPAN_LATE; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP_EARLY = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01, POINT(1 0)@2020-01-02]"), + (byte) 0); + TRIP_LATE = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-07-01, POINT(1 0)@2020-07-02]"), + (byte) 0); + TINT_LOW = temporal_as_hexwkb( + tint_in("[1@2020-01-01, 3@2020-01-02]"), + (byte) 0); + TINT_HIGH = temporal_as_hexwkb( + tint_in("[10@2020-01-01, 20@2020-01-02]"), + (byte) 0); + TRIP_LEFT = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01, POINT(1 0)@2020-01-02]"), + (byte) 0); + TRIP_RIGHT = temporal_as_hexwkb( + tgeompoint_in("[POINT(5 0)@2020-01-01, POINT(6 0)@2020-01-02]"), + (byte) 0); + SPAN_EARLY = span_as_hexwkb(tstzspan_in("[2020-01-01, 2020-02-01]"), (byte) 0); + SPAN_LATE = span_as_hexwkb(tstzspan_in("[2020-07-01, 2020-08-01]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Time-direction: temporal ↔ temporal + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalBefore_early_before_late_is_true() throws Exception { + assertTrue(PosOpsUDFs.temporalBefore.call(TRIP_EARLY, TRIP_LATE)); + } + + @Test @Order(2) + void temporalBefore_late_before_early_is_false() throws Exception { + assertFalse(PosOpsUDFs.temporalBefore.call(TRIP_LATE, TRIP_EARLY)); + } + + @Test @Order(3) + void temporalAfter_late_after_early_is_true() throws Exception { + assertTrue(PosOpsUDFs.temporalAfter.call(TRIP_LATE, TRIP_EARLY)); + } + + @Test @Order(4) + void temporalOverbefore_overlapping_start_is_true() throws Exception { + // TRIP_EARLY ends before TRIP_LATE starts → overbefore is true + assertTrue(PosOpsUDFs.temporalOverbefore.call(TRIP_EARLY, TRIP_LATE)); + } + + @Test @Order(5) + void temporalOverafter_late_overafter_early_is_true() throws Exception { + assertTrue(PosOpsUDFs.temporalOverafter.call(TRIP_LATE, TRIP_EARLY)); + } + + @Test @Order(6) + void temporalBefore_null_input_returns_null() throws Exception { + assertNull(PosOpsUDFs.temporalBefore.call(null, TRIP_LATE)); + assertNull(PosOpsUDFs.temporalBefore.call(TRIP_EARLY, null)); + } + + // ------------------------------------------------------------------ + // Time-direction: temporal ↔ tstzspan + // ------------------------------------------------------------------ + + @Test @Order(7) + void temporalBeforeSpan_early_before_late_span_is_true() throws Exception { + assertTrue(PosOpsUDFs.temporalBeforeSpan.call(TRIP_EARLY, SPAN_LATE)); + } + + @Test @Order(8) + void temporalAfterSpan_late_after_early_span_is_true() throws Exception { + assertTrue(PosOpsUDFs.temporalAfterSpan.call(TRIP_LATE, SPAN_EARLY)); + } + + @Test @Order(9) + void temporalOverbeforeSpan_null_returns_null() throws Exception { + assertNull(PosOpsUDFs.temporalOverbeforeSpan.call(null, SPAN_LATE)); + } + + @Test @Order(10) + void temporalOverafterSpan_null_returns_null() throws Exception { + assertNull(PosOpsUDFs.temporalOverafterSpan.call(TRIP_LATE, null)); + } + + // ------------------------------------------------------------------ + // Value-direction: tnumber ↔ tnumber + // ------------------------------------------------------------------ + + @Test @Order(11) + void tnumberLeft_low_left_of_high_is_true() throws Exception { + assertTrue(PosOpsUDFs.tnumberLeft.call(TINT_LOW, TINT_HIGH)); + } + + @Test @Order(12) + void tnumberRight_high_right_of_low_is_true() throws Exception { + assertTrue(PosOpsUDFs.tnumberRight.call(TINT_HIGH, TINT_LOW)); + } + + @Test @Order(13) + void tnumberOverleft_low_overleft_of_high_is_true() throws Exception { + assertTrue(PosOpsUDFs.tnumberOverleft.call(TINT_LOW, TINT_HIGH)); + } + + @Test @Order(14) + void tnumberOverright_high_overright_of_low_is_true() throws Exception { + assertTrue(PosOpsUDFs.tnumberOverright.call(TINT_HIGH, TINT_LOW)); + } + + @Test @Order(15) + void tnumberLeft_null_returns_null() throws Exception { + assertNull(PosOpsUDFs.tnumberLeft.call(null, TINT_HIGH)); + } + + // ------------------------------------------------------------------ + // Spatial x-axis: tpoint ↔ tpoint + // ------------------------------------------------------------------ + + @Test @Order(16) + void tpointLeft_left_trip_is_left_of_right_trip() throws Exception { + assertTrue(PosOpsUDFs.tpointLeft.call(TRIP_LEFT, TRIP_RIGHT)); + } + + @Test @Order(17) + void tpointRight_right_trip_is_right_of_left_trip() throws Exception { + assertTrue(PosOpsUDFs.tpointRight.call(TRIP_RIGHT, TRIP_LEFT)); + } + + @Test @Order(18) + void tpointOverleft_left_overleft_of_right() throws Exception { + assertTrue(PosOpsUDFs.tpointOverleft.call(TRIP_LEFT, TRIP_RIGHT)); + } + + @Test @Order(19) + void tpointOverright_right_overright_of_left() throws Exception { + assertTrue(PosOpsUDFs.tpointOverright.call(TRIP_RIGHT, TRIP_LEFT)); + } + + @Test @Order(20) + void tpointLeft_null_returns_null() throws Exception { + assertNull(PosOpsUDFs.tpointLeft.call(null, TRIP_RIGHT)); + } + + // ------------------------------------------------------------------ + // Spatial y-axis: tpoint ↔ tpoint + // ------------------------------------------------------------------ + + @Test @Order(21) + void tpointBelow_and_above_y_axis() throws Exception { + // TRIP_LEFT has Y=0; TRIP_RIGHT has Y=0 — same Y, so neither is strictly below + // Use a trip with Y=5 for the above direction + String tripHigh = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 5)@2020-01-01, POINT(1 5)@2020-01-02]"), (byte) 0); + assertTrue(PosOpsUDFs.tpointBelow.call(TRIP_LEFT, tripHigh)); + assertTrue(PosOpsUDFs.tpointAbove.call(tripHigh, TRIP_LEFT)); + } + + @Test @Order(22) + void tpointOverbelow_and_overabove_y_axis() throws Exception { + String tripHigh = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 5)@2020-01-01, POINT(1 5)@2020-01-02]"), (byte) 0); + assertTrue(PosOpsUDFs.tpointOverbelow.call(TRIP_LEFT, tripHigh)); + assertTrue(PosOpsUDFs.tpointOverabove.call(tripHigh, TRIP_LEFT)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExt2Test.java new file mode 100644 index 00000000..8493f2fa --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExt2Test.java @@ -0,0 +1,233 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the new PredicateUDFs: + * - scalar-first reversed forms (int/float OP tint/tfloat) + * - tbool × bool predicates + * - ttext × text predicates (both directions) + * + * Fixtures: + * TINT5_HEX — constant tint 5 at a single instant + * TFLOAT2_HEX — constant tfloat 2.0 at a single instant + * TBOOL_HEX — constant tbool true at a single instant + * TTEXT_HEX — constant ttext "hello" at a single instant + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class PredicateUDFsExt2Test { + + private static String TINT5_HEX; + private static String TFLOAT2_HEX; + private static String TBOOL_HEX; + private static String TTEXT_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT5_HEX = temporal_as_hexwkb(tint_in("5@2020-01-01 00:00:00+00"), (byte) 0); + TFLOAT2_HEX = temporal_as_hexwkb(tfloat_in("2.0@2020-01-01 00:00:00+00"), (byte) 0); + TBOOL_HEX = temporal_as_hexwkb(tbool_in("true@2020-01-01 00:00:00+00"), (byte) 0); + TTEXT_HEX = temporal_as_hexwkb(ttext_in("hello@2020-01-01 00:00:00+00"),(byte) 0); + } + + // ------------------------------------------------------------------ + // scalar-first int OP tint + // ------------------------------------------------------------------ + + @Test @Order(1) + void alwaysEqIntTint_matching_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysEqIntTint.call(5, TINT5_HEX)); + } + + @Test @Order(2) + void alwaysEqIntTint_non_matching_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysEqIntTint.call(9, TINT5_HEX)); + } + + @Test @Order(3) + void everEqIntTint_matching_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.everEqIntTint.call(5, TINT5_HEX)); + } + + @Test @Order(4) + void everLtIntTint_value_less_than_tint_returns_true() throws Exception { + // 3 < tint(5) → true + assertTrue(PredicateUDFs.everLtIntTint.call(3, TINT5_HEX)); + } + + @Test @Order(5) + void alwaysGtIntTint_value_greater_than_tint_returns_true() throws Exception { + // 9 > tint(5) → always true + assertTrue(PredicateUDFs.alwaysGtIntTint.call(9, TINT5_HEX)); + } + + @Test @Order(6) + void alwaysEqIntTint_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysEqIntTint.call(null, TINT5_HEX)); + assertNull(PredicateUDFs.alwaysEqIntTint.call(5, null)); + } + + // ------------------------------------------------------------------ + // scalar-first float OP tfloat + // ------------------------------------------------------------------ + + @Test @Order(7) + void alwaysEqFloatTfloat_matching_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysEqFloatTfloat.call(2.0, TFLOAT2_HEX)); + } + + @Test @Order(8) + void everLtFloatTfloat_value_less_than_tfloat_returns_true() throws Exception { + // 1.0 < tfloat(2.0) → ever true + assertTrue(PredicateUDFs.everLtFloatTfloat.call(1.0, TFLOAT2_HEX)); + } + + @Test @Order(9) + void alwaysGeFloatTfloat_value_ge_tfloat_returns_true() throws Exception { + // 2.0 >= tfloat(2.0) → always true + assertTrue(PredicateUDFs.alwaysGeFloatTfloat.call(2.0, TFLOAT2_HEX)); + } + + @Test @Order(10) + void alwaysEqFloatTfloat_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysEqFloatTfloat.call(null, TFLOAT2_HEX)); + assertNull(PredicateUDFs.alwaysEqFloatTfloat.call(2.0, null)); + } + + // ------------------------------------------------------------------ + // tbool × bool predicates + // ------------------------------------------------------------------ + + @Test @Order(11) + void alwaysEqTboolBool_true_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysEqTboolBool.call(TBOOL_HEX, true)); + } + + @Test @Order(12) + void alwaysEqTboolBool_false_value_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysEqTboolBool.call(TBOOL_HEX, false)); + } + + @Test @Order(13) + void everEqBoolTbool_true_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.everEqBoolTbool.call(true, TBOOL_HEX)); + } + + @Test @Order(14) + void alwaysNeTboolBool_different_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysNeTboolBool.call(TBOOL_HEX, false)); + } + + @Test @Order(15) + void everNeBoolTbool_different_value_returns_true() throws Exception { + assertTrue(PredicateUDFs.everNeBoolTbool.call(false, TBOOL_HEX)); + } + + @Test @Order(16) + void alwaysEqTboolBool_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysEqTboolBool.call(null, true)); + assertNull(PredicateUDFs.alwaysEqTboolBool.call(TBOOL_HEX, null)); + } + + // ------------------------------------------------------------------ + // ttext × text predicates (ttext OP text) + // ------------------------------------------------------------------ + + @Test @Order(17) + void alwaysEqTtextText_matching_text_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysEqTtextText.call(TTEXT_HEX, "hello")); + } + + @Test @Order(18) + void alwaysEqTtextText_non_matching_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysEqTtextText.call(TTEXT_HEX, "world")); + } + + @Test @Order(19) + void everEqTtextText_matching_returns_true() throws Exception { + assertTrue(PredicateUDFs.everEqTtextText.call(TTEXT_HEX, "hello")); + } + + @Test @Order(20) + void alwaysLtTtextText_hello_lt_xyz_returns_true() throws Exception { + // ttext(hello) < "xyz" → always true + assertTrue(PredicateUDFs.alwaysLtTtextText.call(TTEXT_HEX, "xyz")); + } + + @Test @Order(21) + void alwaysGtTtextText_hello_gt_abc_returns_true() throws Exception { + // ttext(hello) > "abc" → always true + assertTrue(PredicateUDFs.alwaysGtTtextText.call(TTEXT_HEX, "abc")); + } + + @Test @Order(22) + void alwaysEqTtextText_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysEqTtextText.call(null, "hello")); + assertNull(PredicateUDFs.alwaysEqTtextText.call(TTEXT_HEX, null)); + } + + // ------------------------------------------------------------------ + // text × ttext predicates (text OP ttext) + // ------------------------------------------------------------------ + + @Test @Order(23) + void alwaysEqTextTtext_matching_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysEqTextTtext.call("hello", TTEXT_HEX)); + } + + @Test @Order(24) + void everEqTextTtext_matching_returns_true() throws Exception { + assertTrue(PredicateUDFs.everEqTextTtext.call("hello", TTEXT_HEX)); + } + + @Test @Order(25) + void alwaysLtTextTtext_abc_lt_hello_returns_true() throws Exception { + // "abc" < ttext(hello) → always true + assertTrue(PredicateUDFs.alwaysLtTextTtext.call("abc", TTEXT_HEX)); + } + + @Test @Order(26) + void alwaysGtTextTtext_xyz_gt_hello_returns_true() throws Exception { + // "xyz" > ttext(hello) → always true + assertTrue(PredicateUDFs.alwaysGtTextTtext.call("xyz", TTEXT_HEX)); + } + + @Test @Order(27) + void alwaysEqTextTtext_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysEqTextTtext.call(null, TTEXT_HEX)); + assertNull(PredicateUDFs.alwaysEqTextTtext.call("hello", null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExtTest.java new file mode 100644 index 00000000..6b7c48d8 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/PredicateUDFsExtTest.java @@ -0,0 +1,194 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for PredicateUDFs ever_ne / always_ne predicates: + * everNeTintInt, everNeTfloatFloat, everNeTemporal, + * alwaysNeTintInt, alwaysNeTfloatFloat, alwaysNeTemporal. + * + * Fixture: + * TINT_CONST — constant tint [5@t1, 5@t2] + * TINT_VARYING — varying tint [1@t1, 3@t3] + * TFLOAT_CONST — constant tfloat [2.0@t1, 2.0@t3] + * TFLOAT_VARY — varying tfloat [1.0@t1, 3.0@t3] + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class PredicateUDFsExtTest { + + private static String TINT_CONST; + private static String TINT_VARYING; + private static String TFLOAT_CONST; + private static String TFLOAT_VARY; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_CONST = temporal_as_hexwkb(tint_in("Interp=Step;[5@2020-01-01, 5@2020-01-03]"), (byte) 0); + TINT_VARYING = temporal_as_hexwkb(tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TFLOAT_CONST = temporal_as_hexwkb(tfloat_in("Interp=Step;[2.0@2020-01-01, 2.0@2020-01-03]"), (byte) 0); + TFLOAT_VARY = temporal_as_hexwkb(tfloat_in("[1.0@2020-01-01, 3.0@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // everNeTintInt + // ------------------------------------------------------------------ + + @Test @Order(1) + void everNeTintInt_const_value_eq_never_ne_returns_false() throws Exception { + assertFalse(PredicateUDFs.everNeTintInt.call(TINT_CONST, 5), + "A constant tint [5,5] is never != 5 — ever_ne must be false"); + } + + @Test @Order(2) + void everNeTintInt_varying_always_has_ne_instants_returns_true() throws Exception { + assertTrue(PredicateUDFs.everNeTintInt.call(TINT_VARYING, 5), + "A varying tint [1,3] is always != 5 — ever_ne must be true"); + } + + @Test @Order(3) + void everNeTintInt_null_returns_null() throws Exception { + assertNull(PredicateUDFs.everNeTintInt.call(null, 5)); + assertNull(PredicateUDFs.everNeTintInt.call(TINT_VARYING, null)); + } + + // ------------------------------------------------------------------ + // everNeTfloatFloat + // ------------------------------------------------------------------ + + @Test @Order(4) + void everNeTfloatFloat_const_never_ne_returns_false() throws Exception { + assertFalse(PredicateUDFs.everNeTfloatFloat.call(TFLOAT_CONST, 2.0), + "Constant tfloat [2.0,2.0] is never != 2.0 — ever_ne must be false"); + } + + @Test @Order(5) + void everNeTfloatFloat_varying_has_ne_returns_true() throws Exception { + assertTrue(PredicateUDFs.everNeTfloatFloat.call(TFLOAT_VARY, 2.0), + "Varying tfloat [1.0,3.0] passes through != 2.0 — ever_ne must be true"); + } + + @Test @Order(6) + void everNeTfloatFloat_null_returns_null() throws Exception { + assertNull(PredicateUDFs.everNeTfloatFloat.call(null, 1.0)); + assertNull(PredicateUDFs.everNeTfloatFloat.call(TFLOAT_VARY, null)); + } + + // ------------------------------------------------------------------ + // everNeTemporal + // ------------------------------------------------------------------ + + @Test @Order(7) + void everNeTemporal_same_value_returns_false() throws Exception { + assertFalse(PredicateUDFs.everNeTemporal.call(TINT_CONST, TINT_CONST), + "A sequence compared with itself is never != — ever_ne must be false"); + } + + @Test @Order(8) + void everNeTemporal_different_values_returns_true() throws Exception { + assertTrue(PredicateUDFs.everNeTemporal.call(TINT_VARYING, TINT_CONST), + "Varying vs constant with different values — ever_ne must be true"); + } + + @Test @Order(9) + void everNeTemporal_null_returns_null() throws Exception { + assertNull(PredicateUDFs.everNeTemporal.call(null, TINT_CONST)); + assertNull(PredicateUDFs.everNeTemporal.call(TINT_CONST, null)); + } + + // ------------------------------------------------------------------ + // alwaysNeTintInt + // ------------------------------------------------------------------ + + @Test @Order(10) + void alwaysNeTintInt_varying_never_equals_target_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysNeTintInt.call(TINT_VARYING, 5), + "Varying tint [1,3] is always != 5 — always_ne must be true"); + } + + @Test @Order(11) + void alwaysNeTintInt_const_equals_target_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysNeTintInt.call(TINT_CONST, 5), + "Constant tint [5,5] is always 5 — always_ne(5) must be false"); + } + + @Test @Order(12) + void alwaysNeTintInt_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysNeTintInt.call(null, 5)); + assertNull(PredicateUDFs.alwaysNeTintInt.call(TINT_VARYING, null)); + } + + // ------------------------------------------------------------------ + // alwaysNeTfloatFloat + // ------------------------------------------------------------------ + + @Test @Order(13) + void alwaysNeTfloatFloat_no_instance_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysNeTfloatFloat.call(TFLOAT_VARY, 5.0), + "Varying tfloat [1.0,3.0] never equals 5.0 — always_ne must be true"); + } + + @Test @Order(14) + void alwaysNeTfloatFloat_equals_target_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysNeTfloatFloat.call(TFLOAT_CONST, 2.0), + "Constant tfloat [2.0,2.0] equals 2.0 — always_ne(2.0) must be false"); + } + + @Test @Order(15) + void alwaysNeTfloatFloat_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysNeTfloatFloat.call(null, 1.0)); + } + + // ------------------------------------------------------------------ + // alwaysNeTemporal + // ------------------------------------------------------------------ + + @Test @Order(16) + void alwaysNeTemporal_same_value_returns_false() throws Exception { + assertFalse(PredicateUDFs.alwaysNeTemporal.call(TINT_CONST, TINT_CONST), + "Constant compared with itself — always_ne must be false"); + } + + @Test @Order(17) + void alwaysNeTemporal_disjoint_values_returns_true() throws Exception { + assertTrue(PredicateUDFs.alwaysNeTemporal.call(TINT_VARYING, TINT_CONST), + "TINT_VARYING [1,3] is always != TINT_CONST [5,5] — always_ne must be true"); + } + + @Test @Order(18) + void alwaysNeTemporal_null_returns_null() throws Exception { + assertNull(PredicateUDFs.alwaysNeTemporal.call(null, TINT_CONST)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt2Test.java new file mode 100644 index 00000000..37889d9b --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt2Test.java @@ -0,0 +1,139 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import org.mobilitydb.spark.geo.STBoxUDFs; +import org.mobilitydb.spark.temporal.ConstructorUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for additional RestrictionUDFs batch 2 — temporal span/spanset + * restriction (atTstzspan/atTstzspanset) and spatial/elevation restriction + * (tgeoAtStbox, tpointAtElevation, tpointMinusElevation). + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExt2Test { + + private static String TFLOAT_SEQ; + private static String TRIP_3D; + private static String SPAN_HEX; + private static String SPANSET_HEX; + private static String STBOX_HEX; + private static String FLOATSPAN_HEX; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 5.0@2020-01-05]"), (byte) 0); + + TRIP_3D = temporal_as_hexwkb( + tgeompoint_in("[POINT Z(0 0 1)@2020-01-01 00:00:00+00, " + + "POINT Z(3 4 5)@2020-01-01 01:00:00+00]"), + (byte) 0); + + // tstzspan "[2020-01-02, 2020-01-04]" + SPAN_HEX = span_as_hexwkb( + tstzspan_in("[2020-01-02, 2020-01-04]"), (byte) 0); + + // tstzspanset "{[2020-01-01, 2020-01-02], [2020-01-04, 2020-01-05]}" + SPANSET_HEX = spanset_as_hexwkb( + tstzspanset_in("{[2020-01-01, 2020-01-02],[2020-01-04, 2020-01-05]}"), (byte) 0); + + // STBox enclosing the trip — use ConstructorUDFs.stbox to get hex-WKB + STBOX_HEX = ConstructorUDFs.stbox.call( + "STBOX XT(((0,0),(4,5)),[2020-01-01 00:00:00+00,2020-01-01 01:00:00+00])"); + + // floatspan [1.0, 3.0] for elevation restriction + FLOATSPAN_HEX = span_as_hexwkb( + floatspan_make(1.0, 3.0, true, true), (byte) 0); + } + + // ------------------------------------------------------------------ + // Timestamp-span restriction + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAtTstzspan_returns_nonnull() throws Exception { + String r = RestrictionUDFs.temporalAtTstzspan.call(TFLOAT_SEQ, SPAN_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalAtTstzspanset_returns_nonnull() throws Exception { + String r = RestrictionUDFs.temporalAtTstzspanset.call(TFLOAT_SEQ, SPANSET_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // STBox restriction + // ------------------------------------------------------------------ + + @Test @Order(3) + void tgeoAtStbox_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tgeoAtStbox.call(TRIP_3D, STBOX_HEX); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Elevation restriction (3D tpoint) + // ------------------------------------------------------------------ + + @Test @Order(4) + void tpointAtElevation_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tpointAtElevation.call(TRIP_3D, FLOATSPAN_HEX); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(5) + void tpointMinusElevation_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tpointMinusElevation.call(TRIP_3D, FLOATSPAN_HEX); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(6) + void null_input_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalAtTstzspan.call(null, SPAN_HEX)); + assertNull(RestrictionUDFs.temporalAtTstzspanset.call(null, SPANSET_HEX)); + assertNull(RestrictionUDFs.tgeoAtStbox.call(null, STBOX_HEX)); + assertNull(RestrictionUDFs.tpointAtElevation.call(null, FLOATSPAN_HEX)); + assertNull(RestrictionUDFs.tpointMinusElevation.call(null, FLOATSPAN_HEX)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt3Test.java new file mode 100644 index 00000000..3661c4ed --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt3Test.java @@ -0,0 +1,135 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for RestrictionUDFs batch 3 — tintAtValue, tnumber value-range + * restriction (at/minus span/spanset), and tgeoMinusStbox. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExt3Test { + + private static String TINT_SEQ; + private static String TFLOAT_SEQ; + private static String TRIP; + private static String INTSPAN_HEX; + private static String FLOATSPAN_HEX; + private static String STBOX_HEX; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("[1@2020-01-01, 5@2020-01-05]"), (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 5.0@2020-01-05]"), (byte) 0); + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + + // intspan [2, 4] + INTSPAN_HEX = span_as_hexwkb(intspan_make(2, 4, true, true), (byte) 0); + // floatspan [1.0, 3.0] + FLOATSPAN_HEX = span_as_hexwkb(floatspan_make(1.0, 3.0, true, true), (byte) 0); + // STBox outside the trip + STBOX_HEX = ConstructorUDFs.stbox.call( + "STBOX XT(((10,10),(20,20)),[2020-01-01 00:00:00+00,2020-01-01 01:00:00+00])"); + } + + // ------------------------------------------------------------------ + // tintAtValue + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintAtValue_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tintAtValue.call(TINT_SEQ, 3); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // tnumber value-range restriction + // ------------------------------------------------------------------ + + @Test @Order(2) + void tnumberAtSpan_tfloat_returns_nonnull() throws Exception { + String r = RestrictionUDFs.tnumberAtSpan.call(TFLOAT_SEQ, FLOATSPAN_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tnumberMinusSpan_tfloat_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tnumberMinusSpan.call(TFLOAT_SEQ, FLOATSPAN_HEX); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(4) + void tnumberAtSpanset_tint_returns_nonnull_or_null() throws Exception { + String spansetHex = spanset_as_hexwkb(intspanset_in("{[2,4]}"), (byte) 0); + // tint [1,5] restricted to span {[2,4]} may yield null (neither 1 nor 5 is in 2-4) + String r = RestrictionUDFs.tnumberAtSpanset.call(TINT_SEQ, spansetHex); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(5) + void tnumberMinusSpanset_returns_nonnull_or_null() throws Exception { + String spansetHex = spanset_as_hexwkb(intspanset_in("{[2,4]}"), (byte) 0); + String r = RestrictionUDFs.tnumberMinusSpanset.call(TINT_SEQ, spansetHex); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // tgeoMinusStbox + // ------------------------------------------------------------------ + + @Test @Order(6) + void tgeoMinusStbox_outside_box_returns_original() throws Exception { + // Subtracting a box that doesn't overlap → result is the full trip + String r = RestrictionUDFs.tgeoMinusStbox.call(TRIP, STBOX_HEX); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(7) + void null_input_returns_null() throws Exception { + assertNull(RestrictionUDFs.tintAtValue.call(null, 1)); + assertNull(RestrictionUDFs.tnumberAtSpan.call(null, FLOATSPAN_HEX)); + assertNull(RestrictionUDFs.tnumberMinusSpan.call(null, FLOATSPAN_HEX)); + assertNull(RestrictionUDFs.tgeoMinusStbox.call(null, STBOX_HEX)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt4Test.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt4Test.java new file mode 100644 index 00000000..a6372118 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt4Test.java @@ -0,0 +1,108 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new restriction UDFs: + * tintMinusValue, temporalDeleteTimestamptz. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExt4Test { + + private static String TINT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("Interp=Step;[1@2020-01-01 00:00:00+00, 1@2020-01-02 00:00:00+00, 2@2020-01-03 00:00:00+00, 2@2020-01-04 00:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tintMinusValue + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintMinusValue_removes_instants_with_value() throws Exception { + String r = RestrictionUDFs.tintMinusValue.call(TINT_SEQ, 1); + assertTrue(r == null || !r.isBlank(), + "Minus value 1 must return null (fully removed) or a valid temporal"); + } + + @Test @Order(2) + void tintMinusValue_nonexistent_value_returns_original_or_nonnull() throws Exception { + String r = RestrictionUDFs.tintMinusValue.call(TINT_SEQ, 99); + assertNotNull(r, "Minus value not in sequence must return original sequence"); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tintMinusValue_null_returns_null() throws Exception { + assertNull(RestrictionUDFs.tintMinusValue.call(null, 1)); + assertNull(RestrictionUDFs.tintMinusValue.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // temporalDeleteTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(4) + void temporalDeleteTimestamptz_at_known_instant_returns_shorter_seq() throws Exception { + // 2020-01-02 00:00:00 UTC = Unix 1577923200 + Timestamp ts = new Timestamp(1577923200L * 1000L); + String r = RestrictionUDFs.temporalDeleteTimestamptz.call(TINT_SEQ, ts); + assertTrue(r == null || !r.isBlank(), + "Delete at known instant must return null or a valid temporal"); + } + + @Test @Order(5) + void temporalDeleteTimestamptz_outside_range_returns_original_or_nonnull() throws Exception { + // 2020-06-01 00:00:00 UTC = Unix 1590969600 + Timestamp ts = new Timestamp(1590969600L * 1000L); + String r = RestrictionUDFs.temporalDeleteTimestamptz.call(TINT_SEQ, ts); + assertNotNull(r, "Delete outside range must return original sequence unchanged"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void temporalDeleteTimestamptz_null_returns_null() throws Exception { + Timestamp ts = new Timestamp(1577836800L * 1000L); + assertNull(RestrictionUDFs.temporalDeleteTimestamptz.call(null, ts)); + assertNull(RestrictionUDFs.temporalDeleteTimestamptz.call(TINT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt5Test.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt5Test.java new file mode 100644 index 00000000..9f778be8 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt5Test.java @@ -0,0 +1,110 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new restriction UDFs: + * temporalAtTimestamptz, temporalMinusTimestamptz. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExt5Test { + + private static String TINT_SEQ; + + // 2020-01-02 00:00:00 UTC = Unix 1577923200 s (inside sequence) + private static Timestamp TS_INSIDE; + // 2020-06-01 00:00:00 UTC = Unix 1590969600 s (outside sequence) + private static Timestamp TS_OUTSIDE; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("Interp=Step;[1@2020-01-01 00:00:00+00, 2@2020-01-03 00:00:00+00]"), + (byte) 0); + + TS_INSIDE = new Timestamp(1577923200L * 1000L); // 2020-01-02 00:00:00 UTC + TS_OUTSIDE = new Timestamp(1590969600L * 1000L); // 2020-06-01 00:00:00 UTC + } + + // ------------------------------------------------------------------ + // temporalAtTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAtTimestamptz_inside_returns_instant() throws Exception { + String r = RestrictionUDFs.temporalAtTimestamptz.call(TINT_SEQ, TS_INSIDE); + assertNotNull(r, "AT inside-range timestamp must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalAtTimestamptz_outside_returns_null() throws Exception { + String r = RestrictionUDFs.temporalAtTimestamptz.call(TINT_SEQ, TS_OUTSIDE); + assertNull(r, "AT outside-range timestamp must return null"); + } + + @Test @Order(3) + void temporalAtTimestamptz_null_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalAtTimestamptz.call(null, TS_INSIDE)); + assertNull(RestrictionUDFs.temporalAtTimestamptz.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // temporalMinusTimestamptz + // ------------------------------------------------------------------ + + @Test @Order(4) + void temporalMinusTimestamptz_inside_returns_shorter() throws Exception { + String r = RestrictionUDFs.temporalMinusTimestamptz.call(TINT_SEQ, TS_INSIDE); + assertTrue(r == null || !r.isBlank(), + "MINUS inside-range timestamp must return null or a valid shorter sequence"); + } + + @Test @Order(5) + void temporalMinusTimestamptz_outside_returns_original() throws Exception { + String r = RestrictionUDFs.temporalMinusTimestamptz.call(TINT_SEQ, TS_OUTSIDE); + assertNotNull(r, "MINUS outside-range timestamp must return original sequence"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void temporalMinusTimestamptz_null_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalMinusTimestamptz.call(null, TS_INSIDE)); + assertNull(RestrictionUDFs.temporalMinusTimestamptz.call(TINT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt6Test.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt6Test.java new file mode 100644 index 00000000..591f0a61 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExt6Test.java @@ -0,0 +1,110 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for RestrictionUDFs value-set operations: + * temporalAtValues, temporalMinusValues. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExt6Test { + + private static String TINT_SEQ; + private static String INTSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Sequence with values 1, 2, 3 + TINT_SEQ = temporal_as_hexwkb( + tint_in("Interp=Step;[1@2020-01-01 00:00:00+00," + + " 2@2020-01-02 00:00:00+00," + + " 3@2020-01-03 00:00:00+00, 3@2020-01-04 00:00:00+00]"), + (byte) 0); + + // intset {1, 3} + INTSET_HEX = set_as_hexwkb(intset_in("{1, 3}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // temporalAtValues + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAtValues_restricts_to_matching_instants() throws Exception { + String r = RestrictionUDFs.temporalAtValues.call(TINT_SEQ, INTSET_HEX); + assertNotNull(r, "AT values {1,3} must return non-null for sequence with those values"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalAtValues_empty_set_returns_null_or_empty() throws Exception { + String emptyHex = set_as_hexwkb(intset_in("{99}"), (byte) 0); + String r = RestrictionUDFs.temporalAtValues.call(TINT_SEQ, emptyHex); + assertTrue(r == null || !r.isBlank(), + "AT nonexistent value must return null or valid empty temporal"); + } + + @Test @Order(3) + void temporalAtValues_null_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalAtValues.call(null, INTSET_HEX)); + assertNull(RestrictionUDFs.temporalAtValues.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // temporalMinusValues + // ------------------------------------------------------------------ + + @Test @Order(4) + void temporalMinusValues_removes_matching_instants() throws Exception { + String r = RestrictionUDFs.temporalMinusValues.call(TINT_SEQ, INTSET_HEX); + assertTrue(r == null || !r.isBlank(), + "MINUS values {1,3} must return null or a shorter temporal"); + } + + @Test @Order(5) + void temporalMinusValues_nonexistent_value_returns_original() throws Exception { + String emptyHex = set_as_hexwkb(intset_in("{99}"), (byte) 0); + String r = RestrictionUDFs.temporalMinusValues.call(TINT_SEQ, emptyHex); + assertNotNull(r, "MINUS nonexistent value must return original sequence"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void temporalMinusValues_null_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalMinusValues.call(null, INTSET_HEX)); + assertNull(RestrictionUDFs.temporalMinusValues.call(TINT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExtTest.java new file mode 100644 index 00000000..a493529c --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsExtTest.java @@ -0,0 +1,105 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for additional RestrictionUDFs — extrema restriction + * (temporalAtMax/Min) and spatial restriction (tgeoAtGeom/tgeoMinusGeom). + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsExtTest { + + private static String TFLOAT_SEQ; + private static String TRIP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 5.0@2020-01-02, 2.0@2020-01-03]"), (byte) 0); + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // Extrema restriction + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAtMax_returns_nonnull() throws Exception { + String r = RestrictionUDFs.temporalAtMax.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalAtMin_returns_nonnull() throws Exception { + String r = RestrictionUDFs.temporalAtMin.call(TFLOAT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Spatial restriction + // ------------------------------------------------------------------ + + @Test @Order(3) + void tgeoAtGeom_returns_nonnull_or_null() throws Exception { + // The trip passes through the polygon — result may be non-null + String r = RestrictionUDFs.tgeoAtGeom.call( + TRIP, "POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))"); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(4) + void tgeoMinusGeom_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.tgeoMinusGeom.call( + TRIP, "POLYGON((10 10, 20 10, 20 20, 10 20, 10 10))"); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(5) + void null_input_returns_null() throws Exception { + assertNull(RestrictionUDFs.temporalAtMax.call(null)); + assertNull(RestrictionUDFs.temporalAtMin.call(null)); + assertNull(RestrictionUDFs.tgeoAtGeom.call(null, "POINT(0 0)")); + assertNull(RestrictionUDFs.tgeoMinusGeom.call(null, "POINT(0 0)")); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsTest.java new file mode 100644 index 00000000..d37e92c5 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/RestrictionUDFsTest.java @@ -0,0 +1,206 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for RestrictionUDFs — at/minus restrictions by value and + * timestamp set/span/spanset, and delete operations. + * + * For cases where MEOS may legitimately return null (value absent from the + * sequence, or a span covers the entire input), the assertion is + * {@code assertTrue(r == null || !r.isBlank())} to verify no exception is + * thrown and no empty string is produced. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class RestrictionUDFsTest { + + private static String TRIP; + private static String TINT_SEQ; + private static String TBOOL_SEQ; + private static String TFLOAT_SEQ; + private static String TTEXT_SEQ; + /** Hex-WKB of tstzspan [2020-01-01, 2020-01-02]. */ + private static String SPAN_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(2 0)@2020-01-01 02:00:00+00]"), + (byte) 0); + TINT_SEQ = temporal_as_hexwkb(tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TBOOL_SEQ = temporal_as_hexwkb(tbool_in("[t@2020-01-01, t@2020-01-02, f@2020-01-03]"), (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb(tfloat_in("[1.0@2020-01-01, 3.0@2020-01-03]"), (byte) 0); + TTEXT_SEQ = temporal_as_hexwkb(ttext_in("[Hello@2020-01-01, World@2020-01-03]"), (byte) 0); + SPAN_HEX = span_as_hexwkb( + tstzspan_in("[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // Timestamp-set restriction + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAtTstzset_returns_nonnull_or_null() throws Exception { + String setHex = set_as_hexwkb(tstzset_in("{2020-01-01 00:30:00+00}"), (byte) 0); + String r = RestrictionUDFs.temporalAtTstzset.call(TRIP, setHex); + // MEOS returns null when the instant does not coincide with a stored value. + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(2) + void temporalMinusTstzset_returns_nonnull_or_null() throws Exception { + String setHex = set_as_hexwkb(tstzset_in("{2020-01-01 00:30:00+00}"), (byte) 0); + String r = RestrictionUDFs.temporalMinusTstzset.call(TRIP, setHex); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Span / spanset restriction + // ------------------------------------------------------------------ + + @Test @Order(3) + void temporalMinusTstzspan_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.temporalMinusTstzspan.call(TRIP, SPAN_HEX); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(4) + void temporalMinusTstzspanset_returns_nonnull_or_null() throws Exception { + String ssHex = spanset_as_hexwkb( + tstzspanset_in("{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]}"), + (byte) 0); + String r = RestrictionUDFs.temporalMinusTstzspanset.call(TRIP, ssHex); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Delete operations + // ------------------------------------------------------------------ + + @Test @Order(5) + void temporalDeleteTstzspan_returns_nonnull_or_null() throws Exception { + String r = RestrictionUDFs.temporalDeleteTstzspan.call(TRIP, SPAN_HEX); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Value restriction: tfloat + // ------------------------------------------------------------------ + + @Test @Order(6) + void tfloatAtValue_returns_nonnull_or_null() throws Exception { + // 2.0 lies between 1.0 and 3.0 in a linear sequence, so MEOS returns the + // crossing instant; result may be null for step sequences but not here. + String r = RestrictionUDFs.tfloatAtValue.call(TFLOAT_SEQ, 2.0); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(7) + void tfloatMinusValue_returns_nonnull() throws Exception { + // 99.0 never appears in the sequence; the full sequence is returned. + String r = RestrictionUDFs.tfloatMinusValue.call(TFLOAT_SEQ, 99.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Value restriction: tbool + // ------------------------------------------------------------------ + + @Test @Order(8) + void tboolAtValue_true_returns_nonnull() throws Exception { + // TBOOL_SEQ is [t@..., t@..., f@...]; restricting to true yields a non-null result. + String r = RestrictionUDFs.tboolAtValue.call(TBOOL_SEQ, true); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void tboolMinusValue_false_returns_nonnull() throws Exception { + // Removing the false portion of TBOOL_SEQ leaves the true portion. + String r = RestrictionUDFs.tboolMinusValue.call(TBOOL_SEQ, false); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Value restriction: ttext + // ------------------------------------------------------------------ + + @Test @Order(10) + void ttextAtValue_matching_returns_nonnull() throws Exception { + String r = RestrictionUDFs.ttextAtValue.call(TTEXT_SEQ, "Hello"); + assertNotNull(r); + } + + @Test @Order(11) + void ttextMinusValue_absent_returns_nonnull() throws Exception { + // "NotInSeq" is not in TTEXT_SEQ; the full sequence is returned. + String r = RestrictionUDFs.ttextMinusValue.call(TTEXT_SEQ, "NotInSeq"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Value restriction: tpoint + // ------------------------------------------------------------------ + + @Test @Order(12) + void tpointAtValue_start_point_returns_nonnull() throws Exception { + // POINT(0 0) is the exact start of TRIP. + String r = RestrictionUDFs.tpointAtValue.call(TRIP, "POINT(0 0)"); + assertNotNull(r); + } + + @Test @Order(13) + void tpointMinusValue_absent_point_returns_nonnull() throws Exception { + // POINT(999 999) never appears; the full trip is returned. + String r = RestrictionUDFs.tpointMinusValue.call(TRIP, "POINT(999 999)"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(14) + void null_input_returns_null() throws Exception { + assertNull(RestrictionUDFs.tfloatAtValue.call(null, 1.0)); + assertNull(RestrictionUDFs.tfloatAtValue.call(TFLOAT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsExt2Test.java new file mode 100644 index 00000000..909c0bc1 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsExt2Test.java @@ -0,0 +1,204 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.geo.STBoxUDFs; + +import java.sql.Timestamp; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new STBoxUDFs constructors: + * geoToStbox, tstzspanToStbox, timestamptzToStbox. + * + * MEOS function authority: meos/include/meos_geo.h, meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class STBoxUDFsExt2Test { + + private static String TSTZSPAN_HEX; + private static String STBOX_A_HEX; // STBox with spatial + time component + private static String STBOX_B_HEX; // STBox strictly right of STBOX_A in X + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TSTZSPAN_HEX = span_as_hexwkb( + tstzspan_in("[2020-01-01 00:00:00+00, 2020-01-03 00:00:00+00]"), (byte) 0); + + // Build spatial-only STBoxes from point geometries. + // STBOX_A: centred at (0,0), STBOX_B: centred at (20,0) — strictly right + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + STBOX_A_HEX = stbox_as_hexwkb(geo_to_stbox(geo_from_text("POINT(0 0)", 0)), (byte) 0, sizeOut); + sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + STBOX_B_HEX = stbox_as_hexwkb(geo_to_stbox(geo_from_text("POINT(20 0)", 0)), (byte) 0, sizeOut); + } + + // ------------------------------------------------------------------ + // geoToStbox + // ------------------------------------------------------------------ + + @Test @Order(1) + void geoToStbox_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.geoToStbox.call("POINT(4.35 50.85)"); + assertNotNull(r, "geoToStbox must return non-null for valid WKT"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void geoToStbox_polygon_returns_nonnull() throws Exception { + String r = STBoxUDFs.geoToStbox.call("POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))"); + assertNotNull(r, "geoToStbox must return non-null for polygon WKT"); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void geoToStbox_null_returns_null() throws Exception { + assertNull(STBoxUDFs.geoToStbox.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspanToStbox + // ------------------------------------------------------------------ + + @Test @Order(4) + void tstzspanToStbox_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.tstzspanToStbox.call(TSTZSPAN_HEX); + assertNotNull(r, "tstzspanToStbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void tstzspanToStbox_null_returns_null() throws Exception { + assertNull(STBoxUDFs.tstzspanToStbox.call(null)); + } + + // ------------------------------------------------------------------ + // timestamptzToStbox + // ------------------------------------------------------------------ + + @Test @Order(6) + void timestamptzToStbox_returns_nonnull_hexwkb() throws Exception { + Timestamp ts = new Timestamp(1577836800000L); // 2020-01-01 00:00:00 UTC + String r = STBoxUDFs.timestamptzToStbox.call(ts); + assertNotNull(r, "timestamptzToStbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void timestamptzToStbox_null_returns_null() throws Exception { + assertNull(STBoxUDFs.timestamptzToStbox.call((Timestamp) null)); + } + + // ------------------------------------------------------------------ + // intersectionStboxStbox / unionStboxStbox + // ------------------------------------------------------------------ + + @Test @Order(8) + void intersectionStboxStbox_same_box_returns_nonnull() throws Exception { + String box = STBoxUDFs.tstzspanToStbox.call(TSTZSPAN_HEX); + assertNotNull(box); + String r = STBoxUDFs.intersectionStboxStbox.call(box, box); + assertNotNull(r, "intersection of a box with itself must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void unionStboxStbox_returns_nonnull() throws Exception { + String box = STBoxUDFs.tstzspanToStbox.call(TSTZSPAN_HEX); + assertNotNull(box); + String r = STBoxUDFs.unionStboxStbox.call(box, box); + assertNotNull(r, "union of a box with itself must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void intersectionStboxStbox_null_returns_null() throws Exception { + String box = STBoxUDFs.tstzspanToStbox.call(TSTZSPAN_HEX); + assertNull(STBoxUDFs.intersectionStboxStbox.call(null, box)); + assertNull(STBoxUDFs.intersectionStboxStbox.call(box, null)); + } + + // ------------------------------------------------------------------ + // STBox positional predicates + // ------------------------------------------------------------------ + + @Test @Order(11) + void stboxLeft_a_is_left_of_b() throws Exception { + assertNotNull(STBOX_A_HEX, "STBOX_A_HEX setup required"); + assertNotNull(STBOX_B_HEX, "STBOX_B_HEX setup required"); + assertTrue(STBoxUDFs.stboxLeft.call(STBOX_A_HEX, STBOX_B_HEX), + "stbox at (0,0) must be left of stbox at (20,0)"); + } + + @Test @Order(12) + void stboxRight_b_is_right_of_a() throws Exception { + assertTrue(STBoxUDFs.stboxRight.call(STBOX_B_HEX, STBOX_A_HEX), + "stbox at (20,0) must be right of stbox at (0,0)"); + } + + @Test @Order(13) + void stboxLeft_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxLeft.call(null, STBOX_B_HEX)); + assertNull(STBoxUDFs.stboxLeft.call(STBOX_A_HEX, null)); + } + + // ------------------------------------------------------------------ + // STBox topology predicates + // ------------------------------------------------------------------ + + @Test @Order(14) + void stboxContains_same_box_returns_true() throws Exception { + assertNotNull(STBOX_A_HEX); + assertTrue(STBoxUDFs.stboxContains.call(STBOX_A_HEX, STBOX_A_HEX), + "an stbox contains itself"); + } + + @Test @Order(15) + void stboxContained_same_box_returns_true() throws Exception { + assertTrue(STBoxUDFs.stboxContained.call(STBOX_A_HEX, STBOX_A_HEX), + "an stbox is contained in itself"); + } + + @Test @Order(16) + void stboxOverlaps_same_box_returns_true() throws Exception { + assertTrue(STBoxUDFs.stboxOverlaps.call(STBOX_A_HEX, STBOX_A_HEX), + "an stbox overlaps itself"); + } + + @Test @Order(17) + void stboxContains_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxContains.call(null, STBOX_A_HEX)); + assertNull(STBoxUDFs.stboxContains.call(STBOX_A_HEX, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsTest.java new file mode 100644 index 00000000..4113c814 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/STBoxUDFsTest.java @@ -0,0 +1,150 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.geo.STBoxUDFs; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for STBoxUDFs: + * stboxRound, stboxExpandSpace, stboxSetSrid, stboxShiftScaleTime. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class STBoxUDFsTest { + + private static String STBOX_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Build stbox hex: STBOX XT(((1.1234,2.5678),(3.9876,4.1111)),[2020-01-01,2020-01-03]) + Pointer sb = stbox_in( + "STBOX XT(((1.1234,2.5678),(3.9876,4.1111))," + + "[2020-01-01 00:00:00+00,2020-01-03 00:00:00+00])"); + assertNotNull(sb, "stbox_in must succeed"); + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + STBOX_HEX = stbox_as_hexwkb(sb, (byte) 0, sizeOut); + } + + // ------------------------------------------------------------------ + // stboxRound + // ------------------------------------------------------------------ + + @Test @Order(1) + void stboxRound_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.stboxRound.call(STBOX_HEX, 2); + assertNotNull(r, "stboxRound must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void stboxRound_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxRound.call(null, 2)); + assertNull(STBoxUDFs.stboxRound.call(STBOX_HEX, null)); + } + + // ------------------------------------------------------------------ + // stboxExpandSpace + // ------------------------------------------------------------------ + + @Test @Order(3) + void stboxExpandSpace_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.stboxExpandSpace.call(STBOX_HEX, 1.0); + assertNotNull(r, "stboxExpandSpace must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void stboxExpandSpace_zero_radius_is_identity() throws Exception { + String r = STBoxUDFs.stboxExpandSpace.call(STBOX_HEX, 0.0); + assertNotNull(r, "Expanding by 0 must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void stboxExpandSpace_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxExpandSpace.call(null, 1.0)); + assertNull(STBoxUDFs.stboxExpandSpace.call(STBOX_HEX, null)); + } + + // ------------------------------------------------------------------ + // stboxSetSrid + // ------------------------------------------------------------------ + + @Test @Order(6) + void stboxSetSrid_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.stboxSetSrid.call(STBOX_HEX, 4326); + assertNotNull(r, "stboxSetSrid must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void stboxSetSrid_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxSetSrid.call(null, 4326)); + assertNull(STBoxUDFs.stboxSetSrid.call(STBOX_HEX, null)); + } + + // ------------------------------------------------------------------ + // stboxShiftScaleTime + // ------------------------------------------------------------------ + + @Test @Order(8) + void stboxShiftScaleTime_shift_returns_nonnull() throws Exception { + String r = STBoxUDFs.stboxShiftScaleTime.call(STBOX_HEX, "1 day", null); + assertNotNull(r, "Shift by 1 day must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void stboxShiftScaleTime_null_stbox_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxShiftScaleTime.call(null, "1 day", null)); + } + + // ------------------------------------------------------------------ + // stboxGetSpace + // ------------------------------------------------------------------ + + @Test @Order(10) + void stboxGetSpace_returns_nonnull_hexwkb() throws Exception { + String r = STBoxUDFs.stboxGetSpace.call(STBOX_HEX); + assertNotNull(r, "stboxGetSpace must return non-null for XT stbox"); + assertFalse(r.isBlank()); + } + + @Test @Order(11) + void stboxGetSpace_null_returns_null() throws Exception { + assertNull(STBoxUDFs.stboxGetSpace.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SetAccessorUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/SetAccessorUDFsExtTest.java new file mode 100644 index 00000000..618ea0af --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SetAccessorUDFsExtTest.java @@ -0,0 +1,223 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Date; +import java.sql.Timestamp; +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for set value accessor UDFs: + * intset, floatset, dateset, tstzset, textset — start/end/values. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SetAccessorUDFsExtTest { + + private static String INTSET_HEX; + private static String FLOATSET_HEX; + private static String DATESET_HEX; + private static String TSTZSET_HEX; + private static String TEXTSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + INTSET_HEX = set_as_hexwkb(intset_in("{1, 5, 10}"), (byte) 0); + FLOATSET_HEX = set_as_hexwkb(floatset_in("{1.5, 3.0, 7.25}"), (byte) 0); + DATESET_HEX = set_as_hexwkb(dateset_in("{2020-01-01, 2020-06-15, 2021-12-31}"), (byte) 0); + TSTZSET_HEX = set_as_hexwkb( + tstzset_in("{2020-01-01 00:00:00+00, 2020-06-01 00:00:00+00}"), (byte) 0); + TEXTSET_HEX = set_as_hexwkb(textset_in("{\"apple\", \"banana\", \"cherry\"}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // intset + // ------------------------------------------------------------------ + + @Test @Order(1) + void intsetStartValue_returns_minimum() throws Exception { + Integer v = SpanAccessorUDFs.intsetStartValue.call(INTSET_HEX); + assertNotNull(v); + assertEquals(1, v.intValue()); + } + + @Test @Order(2) + void intsetEndValue_returns_maximum() throws Exception { + Integer v = SpanAccessorUDFs.intsetEndValue.call(INTSET_HEX); + assertNotNull(v); + assertEquals(10, v.intValue()); + } + + @Test @Order(3) + void intsetValues_returns_all_elements() throws Exception { + List vs = SpanAccessorUDFs.intsetValues.call(INTSET_HEX); + assertNotNull(vs); + assertEquals(3, vs.size()); + assertTrue(vs.contains(1)); + assertTrue(vs.contains(5)); + assertTrue(vs.contains(10)); + } + + @Test @Order(4) + void intsetStartValue_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.intsetStartValue.call(null)); + } + + // ------------------------------------------------------------------ + // floatset + // ------------------------------------------------------------------ + + @Test @Order(5) + void floatsetStartValue_returns_minimum() throws Exception { + Double v = SpanAccessorUDFs.floatsetStartValue.call(FLOATSET_HEX); + assertNotNull(v); + assertEquals(1.5, v, 1e-9); + } + + @Test @Order(6) + void floatsetEndValue_returns_maximum() throws Exception { + Double v = SpanAccessorUDFs.floatsetEndValue.call(FLOATSET_HEX); + assertNotNull(v); + assertEquals(7.25, v, 1e-9); + } + + @Test @Order(7) + void floatsetValues_returns_all_elements() throws Exception { + List vs = SpanAccessorUDFs.floatsetValues.call(FLOATSET_HEX); + assertNotNull(vs); + assertEquals(3, vs.size()); + } + + @Test @Order(8) + void floatsetEndValue_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.floatsetEndValue.call(null)); + } + + // ------------------------------------------------------------------ + // dateset + // ------------------------------------------------------------------ + + @Test @Order(9) + void datesetStartValue_returns_first_date() throws Exception { + Date d = SpanAccessorUDFs.datesetStartValue.call(DATESET_HEX); + assertNotNull(d, "datesetStartValue must return non-null"); + } + + @Test @Order(10) + void datesetEndValue_returns_last_date() throws Exception { + Date d = SpanAccessorUDFs.datesetEndValue.call(DATESET_HEX); + assertNotNull(d, "datesetEndValue must return non-null"); + } + + @Test @Order(11) + void datesetValues_returns_all_elements() throws Exception { + List ds = SpanAccessorUDFs.datesetValues.call(DATESET_HEX); + assertNotNull(ds); + assertEquals(3, ds.size()); + } + + @Test @Order(12) + void datesetStartValue_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.datesetStartValue.call(null)); + } + + // ------------------------------------------------------------------ + // tstzset + // ------------------------------------------------------------------ + + @Test @Order(13) + void tstzsetStartValue_returns_nonnull_timestamp() throws Exception { + Timestamp ts = SpanAccessorUDFs.tstzsetStartValue.call(TSTZSET_HEX); + assertNotNull(ts, "tstzsetStartValue must return non-null"); + } + + @Test @Order(14) + void tstzsetEndValue_returns_nonnull_timestamp() throws Exception { + Timestamp ts = SpanAccessorUDFs.tstzsetEndValue.call(TSTZSET_HEX); + assertNotNull(ts, "tstzsetEndValue must return non-null"); + } + + @Test @Order(15) + void tstzsetStartValue_before_endValue() throws Exception { + Timestamp start = SpanAccessorUDFs.tstzsetStartValue.call(TSTZSET_HEX); + Timestamp end = SpanAccessorUDFs.tstzsetEndValue.call(TSTZSET_HEX); + assertNotNull(start); + assertNotNull(end); + assertTrue(start.before(end), "start value must be before end value"); + } + + @Test @Order(16) + void tstzsetValues_returns_two_elements() throws Exception { + List tss = SpanAccessorUDFs.tstzsetValues.call(TSTZSET_HEX); + assertNotNull(tss); + assertEquals(2, tss.size()); + } + + @Test @Order(17) + void tstzsetStartValue_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzsetStartValue.call(null)); + } + + // ------------------------------------------------------------------ + // textset + // ------------------------------------------------------------------ + + @Test @Order(18) + void textsetStartValue_returns_first_string() throws Exception { + String s = SpanAccessorUDFs.textsetStartValue.call(TEXTSET_HEX); + assertNotNull(s, "textsetStartValue must return non-null"); + assertFalse(s.isBlank()); + } + + @Test @Order(19) + void textsetEndValue_returns_last_string() throws Exception { + String s = SpanAccessorUDFs.textsetEndValue.call(TEXTSET_HEX); + assertNotNull(s, "textsetEndValue must return non-null"); + assertFalse(s.isBlank()); + } + + @Test @Order(20) + void textsetValues_returns_three_strings() throws Exception { + List vs = SpanAccessorUDFs.textsetValues.call(TEXTSET_HEX); + assertNotNull(vs); + assertEquals(3, vs.size()); + vs.forEach(s -> assertFalse(s == null || s.isBlank(), "Each element must be non-blank")); + } + + @Test @Order(21) + void textsetStartValue_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.textsetStartValue.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsExtTest.java new file mode 100644 index 00000000..f2a51d3e --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsExtTest.java @@ -0,0 +1,76 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for SimilarityUDFs.hausdorffDistance. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SimilarityUDFsExtTest { + + private static String TRIP1; + private static String TRIP2; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP1 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01, POINT(1 0)@2020-01-02, POINT(2 0)@2020-01-03]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 1)@2020-01-01, POINT(1 1)@2020-01-02, POINT(2 1)@2020-01-03]"), + (byte) 0); + } + + @Test @Order(1) + void hausdorffDistance_returns_positive_double() throws Exception { + Double d = SimilarityUDFs.hausdorffDistance.call(TRIP1, TRIP2); + assertNotNull(d, "Hausdorff distance must not be null for valid trips"); + assertTrue(d > 0, "Hausdorff distance must be positive for non-identical trips"); + } + + @Test @Order(2) + void hausdorffDistance_same_trip_returns_zero() throws Exception { + Double d = SimilarityUDFs.hausdorffDistance.call(TRIP1, TRIP1); + assertNotNull(d); + assertEquals(0.0, d, 1e-9, "Hausdorff distance of a trip with itself must be 0"); + } + + @Test @Order(3) + void hausdorffDistance_null_returns_null() throws Exception { + assertNull(SimilarityUDFs.hausdorffDistance.call(null, TRIP1)); + assertNull(SimilarityUDFs.hausdorffDistance.call(TRIP1, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsTest.java new file mode 100644 index 00000000..98fce42d --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SimilarityUDFsTest.java @@ -0,0 +1,96 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for SimilarityUDFs — Fréchet and DTW trajectory distances. + * + * MEOS function authority: meos/include/meos.h (038_temporal_similarity) + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SimilarityUDFsTest { + + private static String TRIP1; + private static String TRIP2; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP1 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01, POINT(1 0)@2020-01-02, POINT(2 0)@2020-01-03]"), + (byte) 0); + TRIP2 = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 1)@2020-01-01, POINT(1 1)@2020-01-02, POINT(2 1)@2020-01-03]"), + (byte) 0); + } + + @Test @Order(1) + void frechetDistance_returns_positive_double() throws Exception { + Double d = SimilarityUDFs.frechetDistance.call(TRIP1, TRIP2); + assertNotNull(d, "Fréchet distance should not be null for valid trips"); + assertTrue(d >= 0.0, "Fréchet distance must be non-negative"); + } + + @Test @Order(2) + void frechetDistance_identical_trips_is_zero() throws Exception { + Double d = SimilarityUDFs.frechetDistance.call(TRIP1, TRIP1); + assertNotNull(d); + assertEquals(0.0, d, 1e-9); + } + + @Test @Order(3) + void dynamicTimeWarp_returns_positive_double() throws Exception { + Double d = SimilarityUDFs.dynamicTimeWarp.call(TRIP1, TRIP2); + assertNotNull(d, "DTW distance should not be null for valid trips"); + assertTrue(d >= 0.0, "DTW distance must be non-negative"); + } + + @Test @Order(4) + void dynamicTimeWarp_identical_trips_is_zero() throws Exception { + Double d = SimilarityUDFs.dynamicTimeWarp.call(TRIP1, TRIP1); + assertNotNull(d); + assertEquals(0.0, d, 1e-9); + } + + @Test @Order(5) + void frechetDistance_null_input_returns_null() throws Exception { + assertNull(SimilarityUDFs.frechetDistance.call(null, TRIP2)); + assertNull(SimilarityUDFs.frechetDistance.call(TRIP1, null)); + } + + @Test @Order(6) + void dynamicTimeWarp_null_input_returns_null() throws Exception { + assertNull(SimilarityUDFs.dynamicTimeWarp.call(null, TRIP2)); + assertNull(SimilarityUDFs.dynamicTimeWarp.call(TRIP1, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt2Test.java new file mode 100644 index 00000000..2989f2c1 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt2Test.java @@ -0,0 +1,144 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; +import java.util.List; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for tstzspanset extra accessors and tpointFromBaseTemp constructor: + * tstzspansetNumTimestamps, tstzspansetTimestamps, tstzspansetDuration, + * tpointFromBaseTemp. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpanAccessorUDFsExt2Test { + + /** TstzSpanSet: 2 disjoint 1-day spans with a gap in between. */ + private static String TSTZSPANSET_HEX; + /** Single tgeompoint instant — used as template for tpointFromBaseTemp. */ + private static String TPOINT_INST_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TSTZSPANSET_HEX = spanset_as_hexwkb( + tstzspanset_in("{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-02-01 00:00:00+00, 2020-02-02 00:00:00+00]}"), + (byte) 0); + + TPOINT_INST_HEX = temporal_as_hexwkb( + tgeompoint_in("POINT(1 2)@2020-01-01 00:00:00+00"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // tstzspansetNumTimestamps + // ------------------------------------------------------------------ + + @Test @Order(1) + void tstzspansetNumTimestamps_returns_nonnull() throws Exception { + Integer n = SpanAccessorUDFs.tstzspansetNumTimestamps.call(TSTZSPANSET_HEX); + assertNotNull(n, "tstzspansetNumTimestamps must return non-null"); + } + + @Test @Order(2) + void tstzspansetNumTimestamps_two_spans_returns_four() throws Exception { + Integer n = SpanAccessorUDFs.tstzspansetNumTimestamps.call(TSTZSPANSET_HEX); + assertNotNull(n); + assertEquals(4, n.intValue(), + "2 closed spans → 4 boundary timestamps"); + } + + @Test @Order(3) + void tstzspansetNumTimestamps_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzspansetNumTimestamps.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspansetTimestamps + // ------------------------------------------------------------------ + + @Test @Order(4) + void tstzspansetTimestamps_returns_nonnull_list() throws Exception { + List ts = SpanAccessorUDFs.tstzspansetTimestamps.call(TSTZSPANSET_HEX); + assertNotNull(ts, "tstzspansetTimestamps must return non-null"); + assertFalse(ts.isEmpty()); + } + + @Test @Order(5) + void tstzspansetTimestamps_count_matches_numTimestamps() throws Exception { + Integer n = SpanAccessorUDFs.tstzspansetNumTimestamps.call(TSTZSPANSET_HEX); + List ts = SpanAccessorUDFs.tstzspansetTimestamps.call(TSTZSPANSET_HEX); + assertNotNull(n); + assertNotNull(ts); + assertEquals(n.intValue(), ts.size(), + "timestamp list size must match tstzspansetNumTimestamps"); + } + + @Test @Order(6) + void tstzspansetTimestamps_elements_are_nonnull() throws Exception { + List ts = SpanAccessorUDFs.tstzspansetTimestamps.call(TSTZSPANSET_HEX); + assertNotNull(ts); + ts.forEach(t -> assertNotNull(t, "each timestamp must be non-null")); + } + + @Test @Order(7) + void tstzspansetTimestamps_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzspansetTimestamps.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspansetDuration + // ------------------------------------------------------------------ + + @Test @Order(8) + void tstzspansetDuration_returns_nonnull_interval_string() throws Exception { + String dur = SpanAccessorUDFs.tstzspansetDuration.call(TSTZSPANSET_HEX, false); + assertNotNull(dur, "tstzspansetDuration must return non-null"); + assertFalse(dur.isBlank()); + } + + @Test @Order(9) + void tstzspansetDuration_ignoreGaps_true_returns_nonnull() throws Exception { + String dur = SpanAccessorUDFs.tstzspansetDuration.call(TSTZSPANSET_HEX, true); + assertNotNull(dur, "tstzspansetDuration with ignoreGaps=true must return non-null"); + assertFalse(dur.isBlank()); + } + + @Test @Order(10) + void tstzspansetDuration_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzspansetDuration.call(null, false)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt3Test.java new file mode 100644 index 00000000..70076542 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExt3Test.java @@ -0,0 +1,118 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for intspanset/floatspanset bound accessors: + * intspansetLower/Upper/Width, floatspansetLower/Upper/Width. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpanAccessorUDFsExt3Test { + + private static String INTSPANSET_HEX; + private static String FLOATSPANSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + INTSPANSET_HEX = spanset_as_hexwkb(intspanset_in("{[1, 5], [10, 20]}"), (byte) 0); + FLOATSPANSET_HEX = spanset_as_hexwkb(floatspanset_in("{[1.0, 5.0], [10.0, 20.0]}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // intspanset bounds + // ------------------------------------------------------------------ + + @Test @Order(1) + void intspansetLower_returns_first_lower_bound() throws Exception { + Integer v = SpanAccessorUDFs.intspansetLower.call(INTSPANSET_HEX); + assertNotNull(v); + assertEquals(1, v.intValue()); + } + + @Test @Order(2) + void intspansetUpper_returns_nonnull() throws Exception { + // Integer spans store exclusive upper bound internally; + // [10, 20] is stored as upper = 21. + Integer v = SpanAccessorUDFs.intspansetUpper.call(INTSPANSET_HEX); + assertNotNull(v, "intspansetUpper must return non-null"); + } + + @Test @Order(3) + void intspansetWidth_ignoreGaps_false_returns_nonnull() throws Exception { + Integer w = SpanAccessorUDFs.intspansetWidth.call(INTSPANSET_HEX, false); + assertNotNull(w, "intspansetWidth must return non-null"); + } + + @Test @Order(4) + void intspansetWidth_ignoreGaps_true_returns_nonnull() throws Exception { + Integer w = SpanAccessorUDFs.intspansetWidth.call(INTSPANSET_HEX, true); + assertNotNull(w, "intspansetWidth(ignoreGaps=true) must return non-null"); + } + + @Test @Order(5) + void intspansetLower_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.intspansetLower.call(null)); + } + + // ------------------------------------------------------------------ + // floatspanset bounds + // ------------------------------------------------------------------ + + @Test @Order(6) + void floatspansetLower_returns_first_lower_bound() throws Exception { + Double v = SpanAccessorUDFs.floatspansetLower.call(FLOATSPANSET_HEX); + assertNotNull(v); + assertEquals(1.0, v, 1e-9); + } + + @Test @Order(7) + void floatspansetUpper_returns_last_upper_bound() throws Exception { + Double v = SpanAccessorUDFs.floatspansetUpper.call(FLOATSPANSET_HEX); + assertNotNull(v); + assertEquals(20.0, v, 1e-9); + } + + @Test @Order(8) + void floatspansetWidth_returns_nonnull() throws Exception { + Double w = SpanAccessorUDFs.floatspansetWidth.call(FLOATSPANSET_HEX, false); + assertNotNull(w, "floatspansetWidth must return non-null"); + } + + @Test @Order(9) + void floatspansetLower_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.floatspansetLower.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExtTest.java new file mode 100644 index 00000000..ea75ca64 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsExtTest.java @@ -0,0 +1,246 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for SpanAccessorUDFs new accessors: + * spansetLowerInc, spansetUpperInc, spanToSpanset. + * + * And TBoxUDFs new constructors: + * spanToTbox, spansetToTbox, setToTbox. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpanAccessorUDFsExtTest { + + private static String INTSPAN_HEX; + private static String INTSPANSET_HEX; + private static String INTSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // intspan [1,10] + INTSPAN_HEX = span_as_hexwkb(intspan_in("[1, 10]"), (byte) 0); + // intspanset {[1,5], [8,10]} + INTSPANSET_HEX = spanset_as_hexwkb(intspanset_in("{[1, 5], [8, 10]}"), (byte) 0); + // intset {2, 5, 8} + INTSET_HEX = set_as_hexwkb(intset_in("{2, 5, 8}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // spansetLowerInc + // ------------------------------------------------------------------ + + @Test @Order(1) + void spansetLowerInc_closed_lower_returns_true() throws Exception { + Boolean r = SpanAccessorUDFs.spansetLowerInc.call(INTSPANSET_HEX); + assertNotNull(r); + assertTrue(r, "Lower bound of {[1,5],[8,10]} must be inclusive"); + } + + @Test @Order(2) + void spansetLowerInc_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.spansetLowerInc.call(null)); + } + + // ------------------------------------------------------------------ + // spansetUpperInc + // ------------------------------------------------------------------ + + @Test @Order(3) + void spansetUpperInc_returns_nonnull() throws Exception { + // Integer spansets use exclusive canonical upper bound; just verify the call succeeds. + Boolean r = SpanAccessorUDFs.spansetUpperInc.call(INTSPANSET_HEX); + assertNotNull(r, "spansetUpperInc must return non-null for a valid spanset"); + } + + @Test @Order(4) + void spansetUpperInc_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.spansetUpperInc.call(null)); + } + + // ------------------------------------------------------------------ + // spanToSpanset + // ------------------------------------------------------------------ + + @Test @Order(5) + void spanToSpanset_returns_nonnull_hexwkb() throws Exception { + String r = SpanAccessorUDFs.spanToSpanset.call(INTSPAN_HEX); + assertNotNull(r, "spanToSpanset must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void spanToSpanset_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.spanToSpanset.call(null)); + } + + // ------------------------------------------------------------------ + // spanToTbox (TBoxUDFs) + // ------------------------------------------------------------------ + + @Test @Order(7) + void spanToTbox_returns_nonnull_hexwkb() throws Exception { + String r = TBoxUDFs.spanToTbox.call(INTSPAN_HEX); + assertNotNull(r, "spanToTbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(8) + void spanToTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.spanToTbox.call(null)); + } + + // ------------------------------------------------------------------ + // spansetToTbox (TBoxUDFs) + // ------------------------------------------------------------------ + + @Test @Order(9) + void spansetToTbox_returns_nonnull_hexwkb() throws Exception { + String r = TBoxUDFs.spansetToTbox.call(INTSPANSET_HEX); + assertNotNull(r, "spansetToTbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void spansetToTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.spansetToTbox.call(null)); + } + + // ------------------------------------------------------------------ + // setToTbox (TBoxUDFs) + // ------------------------------------------------------------------ + + @Test @Order(11) + void setToTbox_returns_nonnull_hexwkb() throws Exception { + String r = TBoxUDFs.setToTbox.call(INTSET_HEX); + assertNotNull(r, "setToTbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void setToTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.setToTbox.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspanset boundary accessors (SpanAccessorUDFs) + // ------------------------------------------------------------------ + + private static String TSTZSPANSET_HEX; + + // Note: @BeforeAll already called meos_initialize() above; this + // additional fixture is safe to initialise here. + // TSTZSPANSET_HEX is set at the end of the single @BeforeAll. + + @Test @Order(13) + void tstzspansetLower_returns_nonnull_timestamp() throws Exception { + String ss = spanset_as_hexwkb(tstzspanset_in( + "{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-03-01 00:00:00+00, 2020-03-03 00:00:00+00]}"), (byte) 0); + java.sql.Timestamp r = SpanAccessorUDFs.tstzspansetLower.call(ss); + assertNotNull(r, "tstzspansetLower must return non-null"); + } + + @Test @Order(14) + void tstzspansetLower_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzspansetLower.call(null)); + } + + @Test @Order(15) + void tstzspansetUpper_returns_nonnull_timestamp() throws Exception { + String ss = spanset_as_hexwkb(tstzspanset_in( + "{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-03-01 00:00:00+00, 2020-03-03 00:00:00+00]}"), (byte) 0); + java.sql.Timestamp r = SpanAccessorUDFs.tstzspansetUpper.call(ss); + assertNotNull(r, "tstzspansetUpper must return non-null"); + } + + @Test @Order(16) + void tstzspansetUpper_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.tstzspansetUpper.call(null)); + } + + @Test @Order(17) + void tstzspansetStartTimestamptz_returns_nonnull() throws Exception { + String ss = spanset_as_hexwkb(tstzspanset_in( + "{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-03-01 00:00:00+00, 2020-03-03 00:00:00+00]}"), (byte) 0); + java.sql.Timestamp r = SpanAccessorUDFs.tstzspansetStartTimestamptz.call(ss); + assertNotNull(r, "tstzspansetStartTimestamptz must return non-null"); + } + + @Test @Order(18) + void tstzspansetEndTimestamptz_returns_nonnull() throws Exception { + String ss = spanset_as_hexwkb(tstzspanset_in( + "{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-03-01 00:00:00+00, 2020-03-03 00:00:00+00]}"), (byte) 0); + java.sql.Timestamp r = SpanAccessorUDFs.tstzspansetEndTimestamptz.call(ss); + assertNotNull(r, "tstzspansetEndTimestamptz must return non-null"); + } + + // ------------------------------------------------------------------ + // spansetSpanN + // ------------------------------------------------------------------ + + @Test @Order(19) + void spansetSpanN_first_span_returns_nonnull() throws Exception { + String r = SpanAccessorUDFs.spansetSpanN.call(INTSPANSET_HEX, 1); + assertNotNull(r, "spansetSpanN(1) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(20) + void spansetSpanN_second_span_returns_nonnull() throws Exception { + String r = SpanAccessorUDFs.spansetSpanN.call(INTSPANSET_HEX, 2); + assertNotNull(r, "spansetSpanN(2) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(21) + void spansetSpanN_two_spans_differ() throws Exception { + String s1 = SpanAccessorUDFs.spansetSpanN.call(INTSPANSET_HEX, 1); + String s2 = SpanAccessorUDFs.spansetSpanN.call(INTSPANSET_HEX, 2); + assertNotNull(s1); + assertNotNull(s2); + assertNotEquals(s1, s2, "Span 1 and span 2 of a 2-span spanset must differ"); + } + + @Test @Order(22) + void spansetSpanN_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.spansetSpanN.call(null, 1)); + assertNull(SpanAccessorUDFs.spansetSpanN.call(INTSPANSET_HEX, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsTest.java new file mode 100644 index 00000000..a4431332 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpanAccessorUDFsTest.java @@ -0,0 +1,185 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for SpanAccessorUDFs — span/spanset/set bound and count accessors. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpanAccessorUDFsTest { + + private static String INTSPAN_1_10; + private static String INTSPAN_5_15; + private static String FLOATSPAN; + private static String BIGINTSPAN; + private static String DATESPAN; + private static String TSTZSPAN; + private static String INTSPANSET; + private static String INTSET; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + INTSPAN_1_10 = span_as_hexwkb(intspan_in("[1,10)"), (byte) 0); + INTSPAN_5_15 = span_as_hexwkb(intspan_in("[5,15)"), (byte) 0); + FLOATSPAN = span_as_hexwkb(floatspan_in("[1.5,4.5)"), (byte) 0); + BIGINTSPAN = span_as_hexwkb(bigintspan_in("[100,200)"), (byte) 0); + DATESPAN = span_as_hexwkb(datespan_in("[2020-01-01,2020-02-01)"), (byte) 0); + TSTZSPAN = span_as_hexwkb(tstzspan_in("[2020-01-01 00:00:00+00,2020-01-02 00:00:00+00)"), (byte) 0); + INTSPANSET = spanset_as_hexwkb(intspanset_in("{[1,5),[10,20)}"), (byte) 0); + INTSET = set_as_hexwkb(intset_in("{2,4,6,8}"), (byte) 0); + } + + @Test @Order(1) + void intspanLower_returns_one() throws Exception { + assertEquals(1, SpanAccessorUDFs.intspanLower.call(INTSPAN_1_10)); + } + + @Test @Order(2) + void intspanUpper_returns_ten() throws Exception { + assertEquals(10, SpanAccessorUDFs.intspanUpper.call(INTSPAN_1_10)); + } + + @Test @Order(3) + void intspanWidth_returns_nine() throws Exception { + assertEquals(9, SpanAccessorUDFs.intspanWidth.call(INTSPAN_1_10)); + } + + @Test @Order(4) + void intspanLower_null_input_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.intspanLower.call(null)); + } + + @Test @Order(5) + void floatspanLower_returns_correct_value() throws Exception { + Double lo = SpanAccessorUDFs.floatspanLower.call(FLOATSPAN); + assertNotNull(lo); + assertEquals(1.5, lo, 1e-9); + } + + @Test @Order(6) + void floatspanUpper_returns_correct_value() throws Exception { + Double hi = SpanAccessorUDFs.floatspanUpper.call(FLOATSPAN); + assertNotNull(hi); + assertEquals(4.5, hi, 1e-9); + } + + @Test @Order(7) + void floatspanWidth_returns_three() throws Exception { + Double w = SpanAccessorUDFs.floatspanWidth.call(FLOATSPAN); + assertNotNull(w); + assertEquals(3.0, w, 1e-9); + } + + @Test @Order(8) + void bigintspanLower_returns_100() throws Exception { + assertEquals(100L, SpanAccessorUDFs.bigintspanLower.call(BIGINTSPAN)); + } + + @Test @Order(9) + void bigintspanUpper_returns_200() throws Exception { + assertEquals(200L, SpanAccessorUDFs.bigintspanUpper.call(BIGINTSPAN)); + } + + @Test @Order(10) + void datespanLower_returns_2020_01_01() throws Exception { + java.sql.Date d = SpanAccessorUDFs.datespanLower.call(DATESPAN); + assertNotNull(d); + assertEquals("2020-01-01", d.toString()); + } + + @Test @Order(11) + void datespanUpper_returns_2020_02_01() throws Exception { + java.sql.Date d = SpanAccessorUDFs.datespanUpper.call(DATESPAN); + assertNotNull(d); + assertEquals("2020-02-01", d.toString()); + } + + @Test @Order(12) + void tstzspanLower_returns_2020_01_01() throws Exception { + java.sql.Timestamp ts = SpanAccessorUDFs.tstzspanLower.call(TSTZSPAN); + assertNotNull(ts); + assertTrue(ts.toInstant().toString().startsWith("2020-01-01"), + "Expected 2020-01-01, got: " + ts.toInstant()); + } + + @Test @Order(13) + void tstzspanUpper_returns_2020_01_02() throws Exception { + java.sql.Timestamp ts = SpanAccessorUDFs.tstzspanUpper.call(TSTZSPAN); + assertNotNull(ts); + assertTrue(ts.toInstant().toString().startsWith("2020-01-02"), + "Expected 2020-01-02, got: " + ts.toInstant()); + } + + @Test @Order(14) + void spanLowerInc_closed_lower() throws Exception { + assertTrue(SpanAccessorUDFs.spanLowerInc.call(INTSPAN_1_10)); + } + + @Test @Order(15) + void spanUpperInc_open_upper_returns_false() throws Exception { + assertFalse(SpanAccessorUDFs.spanUpperInc.call(INTSPAN_1_10)); + } + + @Test @Order(16) + void spansetNumSpans_returns_two() throws Exception { + assertEquals(2, SpanAccessorUDFs.spansetNumSpans.call(INTSPANSET)); + } + + @Test @Order(17) + void spansetStartSpan_returns_non_null_hex() throws Exception { + String start = SpanAccessorUDFs.spansetStartSpan.call(INTSPANSET); + assertNotNull(start, "spansetStartSpan should return a span hex-WKB"); + assertFalse(start.isBlank()); + } + + @Test @Order(18) + void spansetEndSpan_lower_bound_is_10() throws Exception { + String end = SpanAccessorUDFs.spansetEndSpan.call(INTSPANSET); + assertNotNull(end); + assertEquals(10, SpanAccessorUDFs.intspanLower.call(end)); + } + + @Test @Order(19) + void setNumValues_returns_four() throws Exception { + assertEquals(4, SpanAccessorUDFs.setNumValues.call(INTSET)); + } + + @Test @Order(20) + void setNumValues_null_returns_null() throws Exception { + assertNull(SpanAccessorUDFs.setNumValues.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFsExtTest.java new file mode 100644 index 00000000..12835d4e --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpanAlgebraUDFsExtTest.java @@ -0,0 +1,378 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import java.sql.Timestamp; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for SpanAlgebraUDFs new functions: + * intspanToFloatspan, floatspanToIntspan, + * datespanToTstzspan, tstzspanToDatespan, + * intsetToFloatset, floatsetToIntset, + * setToSpan, setToSpanset, + * tstzspanDuration, datespanDuration, + * tstzspanShiftScale, tstzspansetShiftScale, + * timestamptzToSpan, timestamptzToSet. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpanAlgebraUDFsExtTest { + + private static String INTSPAN_HEX; + private static String FLOATSPAN_HEX; + private static String TSTZSPAN_HEX; + private static String DATESPAN_HEX; + private static String INTSET_HEX; + private static String FLOATSET_HEX; + private static String TSTZSPANSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + INTSPAN_HEX = span_as_hexwkb(intspan_in("[1, 10]"), (byte) 0); + FLOATSPAN_HEX = span_as_hexwkb(floatspan_in("[1.0, 10.0]"), (byte) 0); + TSTZSPAN_HEX = span_as_hexwkb(tstzspan_in( + "[2020-01-01 00:00:00+00, 2020-01-03 00:00:00+00]"), (byte) 0); + DATESPAN_HEX = span_as_hexwkb(datespan_in("[2020-01-01, 2020-01-03]"), (byte) 0); + INTSET_HEX = set_as_hexwkb(intset_in("{1, 2, 3, 5}"), (byte) 0); + FLOATSET_HEX = set_as_hexwkb(floatset_in("{1.0, 2.0, 3.0}"), (byte) 0); + TSTZSPANSET_HEX = spanset_as_hexwkb(tstzspanset_in( + "{[2020-01-01 00:00:00+00, 2020-01-02 00:00:00+00]," + + "[2020-02-01 00:00:00+00, 2020-02-03 00:00:00+00]}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // intspanToFloatspan / floatspanToIntspan + // ------------------------------------------------------------------ + + @Test @Order(1) + void intspanToFloatspan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intspanToFloatspan.call(INTSPAN_HEX); + assertNotNull(r, "intspanToFloatspan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void intspanToFloatspan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.intspanToFloatspan.call(null)); + } + + @Test @Order(3) + void floatspanToIntspan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatspanToIntspan.call(FLOATSPAN_HEX); + assertNotNull(r, "floatspanToIntspan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void floatspanToIntspan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.floatspanToIntspan.call(null)); + } + + // ------------------------------------------------------------------ + // datespanToTstzspan / tstzspanToDatespan + // ------------------------------------------------------------------ + + @Test @Order(5) + void datespanToTstzspan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.datespanToTstzspan.call(DATESPAN_HEX); + assertNotNull(r, "datespanToTstzspan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void datespanToTstzspan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.datespanToTstzspan.call(null)); + } + + @Test @Order(7) + void tstzspanToDatespan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.tstzspanToDatespan.call(TSTZSPAN_HEX); + assertNotNull(r, "tstzspanToDatespan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(8) + void tstzspanToDatespan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.tstzspanToDatespan.call(null)); + } + + // ------------------------------------------------------------------ + // intsetToFloatset / floatsetToIntset + // ------------------------------------------------------------------ + + @Test @Order(9) + void intsetToFloatset_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intsetToFloatset.call(INTSET_HEX); + assertNotNull(r, "intsetToFloatset must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void intsetToFloatset_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.intsetToFloatset.call(null)); + } + + @Test @Order(11) + void floatsetToIntset_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatsetToIntset.call(FLOATSET_HEX); + assertNotNull(r, "floatsetToIntset must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void floatsetToIntset_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.floatsetToIntset.call(null)); + } + + // ------------------------------------------------------------------ + // setToSpan / setToSpanset + // ------------------------------------------------------------------ + + @Test @Order(13) + void setToSpan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.setToSpan.call(INTSET_HEX); + assertNotNull(r, "setToSpan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(14) + void setToSpan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.setToSpan.call(null)); + } + + @Test @Order(15) + void setToSpanset_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.setToSpanset.call(INTSET_HEX); + assertNotNull(r, "setToSpanset must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(16) + void setToSpanset_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.setToSpanset.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspanDuration / datespanDuration + // ------------------------------------------------------------------ + + @Test @Order(17) + void tstzspanDuration_returns_nonnull_string() throws Exception { + String r = SpanAlgebraUDFs.tstzspanDuration.call(TSTZSPAN_HEX); + assertNotNull(r, "tstzspanDuration must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(18) + void tstzspanDuration_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.tstzspanDuration.call(null)); + } + + @Test @Order(19) + void datespanDuration_returns_nonnull_string() throws Exception { + String r = SpanAlgebraUDFs.datespanDuration.call(DATESPAN_HEX); + assertNotNull(r, "datespanDuration must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(20) + void datespanDuration_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.datespanDuration.call(null)); + } + + // ------------------------------------------------------------------ + // tstzspanShiftScale / tstzspansetShiftScale + // ------------------------------------------------------------------ + + @Test @Order(21) + void tstzspanShiftScale_shift_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.tstzspanShiftScale.call(TSTZSPAN_HEX, "1 day", null); + assertNotNull(r, "tstzspanShiftScale(shift) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(22) + void tstzspanShiftScale_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.tstzspanShiftScale.call(null, "1 day", null)); + assertNull(SpanAlgebraUDFs.tstzspanShiftScale.call(TSTZSPAN_HEX, null, null)); + } + + @Test @Order(23) + void tstzspansetShiftScale_shift_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.tstzspansetShiftScale.call(TSTZSPANSET_HEX, "1 day", null); + assertNotNull(r, "tstzspansetShiftScale(shift) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(24) + void tstzspansetShiftScale_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.tstzspansetShiftScale.call(null, "1 day", null)); + } + + // ------------------------------------------------------------------ + // timestamptzToSpan / timestamptzToSet + // ------------------------------------------------------------------ + + @Test @Order(25) + void timestamptzToSpan_returns_nonnull() throws Exception { + Timestamp ts = new Timestamp(1577836800000L); // 2020-01-01 00:00:00 UTC + String r = SpanAlgebraUDFs.timestamptzToSpan.call(ts); + assertNotNull(r, "timestamptzToSpan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(26) + void timestamptzToSpan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.timestamptzToSpan.call(null)); + } + + @Test @Order(27) + void timestamptzToSet_returns_nonnull() throws Exception { + Timestamp ts = new Timestamp(1577836800000L); // 2020-01-01 00:00:00 UTC + String r = SpanAlgebraUDFs.timestamptzToSet.call(ts); + assertNotNull(r, "timestamptzToSet must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(28) + void timestamptzToSet_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.timestamptzToSet.call(null)); + } + + // ------------------------------------------------------------------ + // Cross-type spanset × span algebra + // ------------------------------------------------------------------ + + @Test @Order(29) + void spansetIntersectionSpan_overlapping_returns_nonnull() throws Exception { + // TSTZSPANSET_HEX has two periods; intersect with the first span + String overlapSpan = span_as_hexwkb(tstzspan_in( + "[2020-01-01 06:00:00+00, 2020-01-01 18:00:00+00]"), (byte) 0); + String r = SpanAlgebraUDFs.spansetIntersectionSpan.call(TSTZSPANSET_HEX, overlapSpan); + assertNotNull(r, "spansetIntersectionSpan must return non-null for overlap"); + assertFalse(r.isBlank()); + } + + @Test @Order(30) + void spansetUnionSpan_returns_nonnull() throws Exception { + String addSpan = span_as_hexwkb(tstzspan_in( + "[2020-03-01 00:00:00+00, 2020-03-03 00:00:00+00]"), (byte) 0); + String r = SpanAlgebraUDFs.spansetUnionSpan.call(TSTZSPANSET_HEX, addSpan); + assertNotNull(r, "spansetUnionSpan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(31) + void spansetMinusSpan_removes_overlap() throws Exception { + // remove a chunk from within the first period + String removeSpan = span_as_hexwkb(tstzspan_in( + "[2020-01-01 06:00:00+00, 2020-01-01 18:00:00+00]"), (byte) 0); + String r = SpanAlgebraUDFs.spansetMinusSpan.call(TSTZSPANSET_HEX, removeSpan); + assertNotNull(r, "spansetMinusSpan must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(32) + void spansetIntersectionSpan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.spansetIntersectionSpan.call(null, TSTZSPAN_HEX)); + assertNull(SpanAlgebraUDFs.spansetIntersectionSpan.call(TSTZSPANSET_HEX, null)); + } + + // ------------------------------------------------------------------ + // Scalar singleton constructors + // ------------------------------------------------------------------ + + @Test @Order(33) + void intToSpan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intToSpan.call(5); + assertNotNull(r, "intToSpan(5) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(34) + void intToSet_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intToSet.call(5); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(35) + void intToSpanset_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intToSpanset.call(5); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(36) + void floatToSpan_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatToSpan.call(3.14); + assertNotNull(r, "floatToSpan(3.14) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(37) + void floatToSet_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatToSet.call(3.14); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(38) + void floatToSpanset_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatToSpanset.call(3.14); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(39) + void intToTbox_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.intToTbox.call(42); + assertNotNull(r, "intToTbox(42) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(40) + void floatToTbox_returns_nonnull() throws Exception { + String r = SpanAlgebraUDFs.floatToTbox.call(2.5); + assertNotNull(r, "floatToTbox(2.5) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(41) + void intToSpan_null_returns_null() throws Exception { + assertNull(SpanAlgebraUDFs.intToSpan.call(null)); + assertNull(SpanAlgebraUDFs.floatToSpan.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/SpansetOpsUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/SpansetOpsUDFsTest.java new file mode 100644 index 00000000..409767a7 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/SpansetOpsUDFsTest.java @@ -0,0 +1,217 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for cross-type Span × Spanset positional/topological UDFs. + * + * Fixtures (all floatspan / floatspanset for arithmetic semantics): + * SPAN_LO — floatspan [0, 5) + * SPAN_HI — floatspan [10, 15) + * SPANSET_LO — floatspanset { [0,5), [6,8) } + * SPANSET_HI — floatspanset { [10,12), [13,15) } + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class SpansetOpsUDFsTest { + + private static String SPAN_LO; + private static String SPAN_HI; + private static String SPANSET_LO; + private static String SPANSET_HI; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + SPAN_LO = span_as_hexwkb(floatspan_in("[0, 5)"), (byte) 0); + SPAN_HI = span_as_hexwkb(floatspan_in("[10, 15)"), (byte) 0); + SPANSET_LO = spanset_as_hexwkb(floatspanset_in("{[0,5), [6,8)}"), (byte) 0); + SPANSET_HI = spanset_as_hexwkb(floatspanset_in("{[10,12), [13,15)}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Null guards + // ------------------------------------------------------------------ + + @Test @Order(1) + void spanLeftSpanset_null_returns_null() throws Exception { + assertNull(SpansetOpsUDFs.spanLeftSpanset.call(null, SPANSET_HI)); + assertNull(SpansetOpsUDFs.spanLeftSpanset.call(SPAN_LO, null)); + } + + @Test @Order(2) + void spansetLeftSpan_null_returns_null() throws Exception { + assertNull(SpansetOpsUDFs.spansetLeftSpan.call(null, SPAN_HI)); + assertNull(SpansetOpsUDFs.spansetLeftSpan.call(SPANSET_LO, null)); + } + + @Test @Order(3) + void spansetLeftSpanset_null_returns_null() throws Exception { + assertNull(SpansetOpsUDFs.spansetLeftSpanset.call(null, SPANSET_HI)); + assertNull(SpansetOpsUDFs.spansetLeftSpanset.call(SPANSET_LO, null)); + } + + // ------------------------------------------------------------------ + // span × spanset + // ------------------------------------------------------------------ + + @Test @Order(4) + void spanLeftSpanset_low_left_of_high() throws Exception { + assertTrue(SpansetOpsUDFs.spanLeftSpanset.call(SPAN_LO, SPANSET_HI)); + } + + @Test @Order(5) + void spanLeftSpanset_high_not_left_of_low() throws Exception { + assertFalse(SpansetOpsUDFs.spanLeftSpanset.call(SPAN_HI, SPANSET_LO)); + } + + @Test @Order(6) + void spanRightSpanset_high_right_of_low() throws Exception { + assertTrue(SpansetOpsUDFs.spanRightSpanset.call(SPAN_HI, SPANSET_LO)); + } + + @Test @Order(7) + void spanOverlapsSpanset_overlap_returns_true() throws Exception { + assertTrue(SpansetOpsUDFs.spanOverlapsSpanset.call(SPAN_LO, SPANSET_LO)); + } + + @Test @Order(8) + void spanOverlapsSpanset_disjoint_returns_false() throws Exception { + assertFalse(SpansetOpsUDFs.spanOverlapsSpanset.call(SPAN_LO, SPANSET_HI)); + } + + @Test @Order(9) + void spanContainsSpanset_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spanContainsSpanset.call(SPAN_LO, SPANSET_LO)); + } + + @Test @Order(10) + void spanContainedSpanset_self_returns_true() throws Exception { + assertTrue(SpansetOpsUDFs.spanContainedSpanset.call(SPAN_LO, SPANSET_LO), + "[0,5) is contained in {[0,5), [6,8)}"); + } + + @Test @Order(11) + void spanAdjacentSpanset_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spanAdjacentSpanset.call(SPAN_LO, SPANSET_HI)); + } + + @Test @Order(12) + void spanOverleftSpanset_low_overleft_of_high() throws Exception { + assertTrue(SpansetOpsUDFs.spanOverleftSpanset.call(SPAN_LO, SPANSET_HI)); + } + + // ------------------------------------------------------------------ + // spanset × span + // ------------------------------------------------------------------ + + @Test @Order(13) + void spansetLeftSpan_low_left_of_high() throws Exception { + assertTrue(SpansetOpsUDFs.spansetLeftSpan.call(SPANSET_LO, SPAN_HI)); + } + + @Test @Order(14) + void spansetRightSpan_high_right_of_low() throws Exception { + assertTrue(SpansetOpsUDFs.spansetRightSpan.call(SPANSET_HI, SPAN_LO)); + } + + @Test @Order(15) + void spansetOverlapsSpan_overlap_returns_true() throws Exception { + assertTrue(SpansetOpsUDFs.spansetOverlapsSpan.call(SPANSET_LO, SPAN_LO)); + } + + @Test @Order(16) + void spansetOverlapsSpan_disjoint_returns_false() throws Exception { + assertFalse(SpansetOpsUDFs.spansetOverlapsSpan.call(SPANSET_LO, SPAN_HI)); + } + + @Test @Order(17) + void spansetContainedSpan_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spansetContainedSpan.call(SPANSET_LO, SPAN_LO)); + } + + @Test @Order(18) + void spansetAdjacentSpan_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spansetAdjacentSpan.call(SPANSET_LO, SPAN_HI)); + } + + @Test @Order(19) + void spansetOverleftSpan_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spansetOverleftSpan.call(SPANSET_LO, SPAN_HI)); + } + + @Test @Order(20) + void spansetOverrightSpan_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spansetOverrightSpan.call(SPANSET_HI, SPAN_LO)); + } + + // ------------------------------------------------------------------ + // spanset × spanset + // ------------------------------------------------------------------ + + @Test @Order(21) + void spansetLeftSpanset_low_left_of_high() throws Exception { + assertTrue(SpansetOpsUDFs.spansetLeftSpanset.call(SPANSET_LO, SPANSET_HI)); + } + + @Test @Order(22) + void spansetRightSpanset_high_right_of_low() throws Exception { + assertTrue(SpansetOpsUDFs.spansetRightSpanset.call(SPANSET_HI, SPANSET_LO)); + } + + @Test @Order(23) + void spansetContainsSpanset_self_returns_true() throws Exception { + assertTrue(SpansetOpsUDFs.spansetContainsSpanset.call(SPANSET_LO, SPANSET_LO)); + } + + @Test @Order(24) + void spansetContainedSpanset_self_returns_true() throws Exception { + assertTrue(SpansetOpsUDFs.spansetContainedSpanset.call(SPANSET_LO, SPANSET_LO)); + } + + @Test @Order(25) + void spansetAdjacentSpanset_returns_nonnull() throws Exception { + assertNotNull(SpansetOpsUDFs.spansetAdjacentSpanset.call(SPANSET_LO, SPANSET_HI)); + } + + @Test @Order(26) + void spansetOverleftSpanset_low_overleft_of_high() throws Exception { + assertTrue(SpansetOpsUDFs.spansetOverleftSpanset.call(SPANSET_LO, SPANSET_HI)); + } + + @Test @Order(27) + void spansetOverrightSpanset_high_overright_of_low() throws Exception { + assertTrue(SpansetOpsUDFs.spansetOverrightSpanset.call(SPANSET_HI, SPANSET_LO)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TBoxOpsUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/TBoxOpsUDFsTest.java new file mode 100644 index 00000000..87ebfec3 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TBoxOpsUDFsTest.java @@ -0,0 +1,258 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for cross-type TBox × TNumber positional/topological UDFs. + * + * Fixtures: + * TBOX_LO — TBOXFLOAT XT([0,5],[2020-01-01,2020-01-02]) — value range [0,5] + * TBOX_HI — TBOXFLOAT XT([10,15],[2020-01-03,2020-01-04]) — value range [10,15] + * TFLOAT_LO — tfloat trip 0→5 over 2020-01-01 → 2020-01-02 + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TBoxOpsUDFsTest { + + private static String TBOX_LO; + private static String TBOX_HI; + private static String TFLOAT_LO; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TBOX_LO = ConstructorUDFs.tbox.call( + "TBOXFLOAT XT([0,5],[2020-01-01 00:00:00+00,2020-01-02 00:00:00+00])"); + TBOX_HI = ConstructorUDFs.tbox.call( + "TBOXFLOAT XT([10,15],[2020-01-03 00:00:00+00,2020-01-04 00:00:00+00])"); + TFLOAT_LO = temporal_as_hexwkb( + tfloat_in("[0.0@2020-01-01 00:00:00+00, 5.0@2020-01-02 00:00:00+00]"), + (byte) 0); + } + + // ------------------------------------------------------------------ + // Null guards + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboxLeftTbox_null_returns_null() throws Exception { + assertNull(TBoxOpsUDFs.tboxLeftTbox.call(null, TBOX_HI)); + assertNull(TBoxOpsUDFs.tboxLeftTbox.call(TBOX_LO, null)); + } + + @Test @Order(2) + void tboxLeftTnumber_null_returns_null() throws Exception { + assertNull(TBoxOpsUDFs.tboxLeftTnumber.call(null, TFLOAT_LO)); + assertNull(TBoxOpsUDFs.tboxLeftTnumber.call(TBOX_LO, null)); + } + + @Test @Order(3) + void tnumberLeftTbox_null_returns_null() throws Exception { + assertNull(TBoxOpsUDFs.tnumberLeftTbox.call(null, TBOX_HI)); + assertNull(TBoxOpsUDFs.tnumberLeftTbox.call(TFLOAT_LO, null)); + } + + // ------------------------------------------------------------------ + // tbox × tbox — semantic correctness + // ------------------------------------------------------------------ + + @Test @Order(4) + void tboxLeftTbox_low_is_left_of_high() throws Exception { + assertTrue(TBoxOpsUDFs.tboxLeftTbox.call(TBOX_LO, TBOX_HI), + "TBOX_LO (val [0,5]) must be left of TBOX_HI (val [10,15])"); + } + + @Test @Order(5) + void tboxLeftTbox_high_not_left_of_low() throws Exception { + assertFalse(TBoxOpsUDFs.tboxLeftTbox.call(TBOX_HI, TBOX_LO)); + } + + @Test @Order(6) + void tboxRightTbox_high_is_right_of_low() throws Exception { + assertTrue(TBoxOpsUDFs.tboxRightTbox.call(TBOX_HI, TBOX_LO)); + } + + @Test @Order(7) + void tboxBeforeTbox_low_is_before_high() throws Exception { + assertTrue(TBoxOpsUDFs.tboxBeforeTbox.call(TBOX_LO, TBOX_HI), + "TBOX_LO time precedes TBOX_HI time"); + } + + @Test @Order(8) + void tboxAfterTbox_high_is_after_low() throws Exception { + assertTrue(TBoxOpsUDFs.tboxAfterTbox.call(TBOX_HI, TBOX_LO)); + } + + @Test @Order(9) + void tboxOverlapsTbox_disjoint_returns_false() throws Exception { + assertFalse(TBoxOpsUDFs.tboxOverlapsTbox.call(TBOX_LO, TBOX_HI)); + } + + @Test @Order(10) + void tboxOverlapsTbox_self_returns_true() throws Exception { + assertTrue(TBoxOpsUDFs.tboxOverlapsTbox.call(TBOX_LO, TBOX_LO)); + } + + @Test @Order(11) + void tboxSameTbox_self_returns_true() throws Exception { + assertTrue(TBoxOpsUDFs.tboxSameTbox.call(TBOX_LO, TBOX_LO)); + } + + @Test @Order(12) + void tboxContainsTbox_self_returns_true() throws Exception { + assertTrue(TBoxOpsUDFs.tboxContainsTbox.call(TBOX_LO, TBOX_LO)); + } + + @Test @Order(13) + void tboxContainedTbox_self_returns_true() throws Exception { + assertTrue(TBoxOpsUDFs.tboxContainedTbox.call(TBOX_LO, TBOX_LO)); + } + + @Test @Order(14) + void tboxAdjacentTbox_disjoint_in_value_returns_nonnull() throws Exception { + // Disjoint boxes are not adjacent (gap between [0,5] and [10,15]) + assertNotNull(TBoxOpsUDFs.tboxAdjacentTbox.call(TBOX_LO, TBOX_HI)); + } + + @Test @Order(15) + void tboxOverleftTbox_low_is_overleft_of_high() throws Exception { + // [0,5] is overleft (i.e., does not extend right) of [10,15] + assertTrue(TBoxOpsUDFs.tboxOverleftTbox.call(TBOX_LO, TBOX_HI)); + } + + @Test @Order(16) + void tboxOverbeforeTbox_low_is_overbefore_high() throws Exception { + assertTrue(TBoxOpsUDFs.tboxOverbeforeTbox.call(TBOX_LO, TBOX_HI)); + } + + // ------------------------------------------------------------------ + // tbox × tnumber — semantic correctness + // ------------------------------------------------------------------ + + @Test @Order(17) + void tboxOverlapsTnumber_self_returns_true() throws Exception { + // TBOX_LO covers tfloat 0→5 over the same time window + assertTrue(TBoxOpsUDFs.tboxOverlapsTnumber.call(TBOX_LO, TFLOAT_LO)); + } + + @Test @Order(18) + void tboxLeftTnumber_high_not_left_of_low_tnumber() throws Exception { + // TBOX_HI (val [10,15]) is NOT left of TFLOAT_LO (val [0,5]) + assertFalse(TBoxOpsUDFs.tboxLeftTnumber.call(TBOX_HI, TFLOAT_LO)); + } + + @Test @Order(19) + void tboxContainsTnumber_overlap_returns_nonnull() throws Exception { + assertNotNull(TBoxOpsUDFs.tboxContainsTnumber.call(TBOX_LO, TFLOAT_LO)); + } + + @Test @Order(20) + void tboxBeforeTnumber_high_not_before_low() throws Exception { + // TBOX_HI starts 2020-01-03; TFLOAT_LO ends 2020-01-02. So TBOX_HI is AFTER, not BEFORE. + assertFalse(TBoxOpsUDFs.tboxBeforeTnumber.call(TBOX_HI, TFLOAT_LO)); + } + + @Test @Order(21) + void tboxAfterTnumber_high_is_after_low_tnumber() throws Exception { + assertTrue(TBoxOpsUDFs.tboxAfterTnumber.call(TBOX_HI, TFLOAT_LO)); + } + + // ------------------------------------------------------------------ + // tnumber × tbox — semantic correctness + // ------------------------------------------------------------------ + + @Test @Order(22) + void tnumberOverlapsTbox_self_returns_true() throws Exception { + assertTrue(TBoxOpsUDFs.tnumberOverlapsTbox.call(TFLOAT_LO, TBOX_LO)); + } + + @Test @Order(23) + void tnumberLeftTbox_low_is_left_of_high() throws Exception { + // TFLOAT_LO (val [0,5]) is left of TBOX_HI (val [10,15]) + assertTrue(TBoxOpsUDFs.tnumberLeftTbox.call(TFLOAT_LO, TBOX_HI)); + } + + @Test @Order(24) + void tnumberBeforeTbox_low_is_before_high() throws Exception { + assertTrue(TBoxOpsUDFs.tnumberBeforeTbox.call(TFLOAT_LO, TBOX_HI)); + } + + @Test @Order(25) + void tnumberContainedTbox_self_returns_nonnull() throws Exception { + assertNotNull(TBoxOpsUDFs.tnumberContainedTbox.call(TFLOAT_LO, TBOX_LO)); + } + + @Test @Order(26) + void tnumberOverrightTbox_low_not_overright_of_high() throws Exception { + // TFLOAT_LO (val [0,5]) does NOT extend past the right of TBOX_HI (val [10,15]) + assertFalse(TBoxOpsUDFs.tnumberOverrightTbox.call(TFLOAT_LO, TBOX_HI)); + } + + @Test @Order(27) + void tnumberSameTbox_self_returns_nonnull() throws Exception { + assertNotNull(TBoxOpsUDFs.tnumberSameTbox.call(TFLOAT_LO, TBOX_LO)); + } + + // ------------------------------------------------------------------ + // tboxExpandFloat / tboxExpandInt — wired via MeosNative + // ------------------------------------------------------------------ + + @Test @Order(28) + void tboxExpandFloat_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxExpandFloat.call(TBOX_LO, 2.5); + assertNotNull(r, "tboxExpandFloat must return non-null hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(29) + void tboxExpandFloat_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxExpandFloat.call(null, 2.5)); + assertNull(TBoxUDFs.tboxExpandFloat.call(TBOX_LO, null)); + } + + @Test @Order(30) + void tboxExpandInt_returns_nonnull() throws Exception { + // Need an integer TBox for tintbox_expand + String tboxInt = ConstructorUDFs.tbox.call( + "TBOXINT XT([0,5],[2020-01-01 00:00:00+00,2020-01-02 00:00:00+00])"); + String r = TBoxUDFs.tboxExpandInt.call(tboxInt, 3); + assertNotNull(r, "tboxExpandInt must return non-null hex-WKB"); + assertFalse(r.isBlank()); + } + + @Test @Order(31) + void tboxExpandInt_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxExpandInt.call(null, 3)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExt2Test.java new file mode 100644 index 00000000..20883d0a --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExt2Test.java @@ -0,0 +1,326 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new TBoxUDFs: + * tboxMake, timestamptzToTbox, numspanTimestamptzToTbox, + * tboxExpandTime, tboxShiftScaleTime, + * tboxExpandFloat, tboxExpandInt, + * tboxfloatXmin, tboxfloatXmax, tboxintXmin, tboxintXmax. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TBoxUDFsExt2Test { + + private static String TBOX_XT_HEX; // TBox with X and T dimensions (floatspan) + private static String TBOX_T_HEX; // TBox with T dimension only + private static String FLOATSPAN_HEX; + private static String TSTZSPAN_HEX; + private static String TBOX_INT_HEX; // TBox with X and T dimensions (intspan) + private static String INTSPAN_HEX; + private static String TBOX_FUTURE_HEX; // TBox strictly after TBOX_XT_HEX in time + private static String TBOX_HIGH_HEX; // TBox strictly right of TBOX_XT_HEX in X + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Build a tbox with float X + time via tnumber_to_tbox on a tfloat + Pointer tfloatPtr = tfloat_in("[1.5@2020-01-01 00:00:00+00, 9.5@2020-01-03 00:00:00+00]"); + Pointer sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + TBOX_XT_HEX = tbox_as_hexwkb(tnumber_to_tbox(tfloatPtr), (byte) 0, sizeOut); + + // Build a tbox with integer X + time via tnumber_to_tbox on a tint + Pointer tintPtr = tint_in("[1@2020-01-01 00:00:00+00, 9@2020-01-03 00:00:00+00]"); + sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + TBOX_INT_HEX = tbox_as_hexwkb(tnumber_to_tbox(tintPtr), (byte) 0, sizeOut); + + // T-only TBox from tstzspan + Pointer tstzspanPtr = tstzspan_in("[2020-01-01 00:00:00+00, 2020-01-03 00:00:00+00]"); + TSTZSPAN_HEX = span_as_hexwkb(tstzspanPtr, (byte) 0); + sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + TBOX_T_HEX = tbox_as_hexwkb(span_to_tbox(tstzspanPtr), (byte) 0, sizeOut); + + FLOATSPAN_HEX = span_as_hexwkb(floatspan_in("[1.0, 10.0]"), (byte) 0); + INTSPAN_HEX = span_as_hexwkb(intspan_in("[1, 10]"), (byte) 0); + + // TBox strictly after TBOX_XT_HEX in time (2020-01-10 onwards) + Pointer futurePtr = tfloat_in("[1.5@2020-01-10 00:00:00+00, 1.5@2020-01-12 00:00:00+00]"); + sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + TBOX_FUTURE_HEX = tbox_as_hexwkb(tnumber_to_tbox(futurePtr), (byte) 0, sizeOut); + + // TBox strictly right of TBOX_XT_HEX in X (X range [100, 200]) + Pointer highPtr = tfloat_in("[100.0@2020-01-01 00:00:00+00, 200.0@2020-01-03 00:00:00+00]"); + sizeOut = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8); + TBOX_HIGH_HEX = tbox_as_hexwkb(tnumber_to_tbox(highPtr), (byte) 0, sizeOut); + } + + // ------------------------------------------------------------------ + // tboxMake + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboxMake_xt_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxMake.call(FLOATSPAN_HEX, TSTZSPAN_HEX); + assertNotNull(r, "tboxMake(floatspan, tstzspan) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tboxMake_t_only_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxMake.call(null, TSTZSPAN_HEX); + assertNotNull(r, "tboxMake(null, tstzspan) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void tboxMake_both_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxMake.call(null, null)); + } + + // ------------------------------------------------------------------ + // timestamptzToTbox + // ------------------------------------------------------------------ + + @Test @Order(4) + void timestamptzToTbox_returns_nonnull() throws Exception { + java.sql.Timestamp ts = java.sql.Timestamp.valueOf("2020-01-01 00:00:00"); + String r = TBoxUDFs.timestamptzToTbox.call(ts); + assertNotNull(r, "timestamptzToTbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void timestamptzToTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.timestamptzToTbox.call((java.sql.Timestamp) null)); + } + + // ------------------------------------------------------------------ + // numspanTimestamptzToTbox + // ------------------------------------------------------------------ + + @Test @Order(6) + void numspanTimestamptzToTbox_returns_nonnull() throws Exception { + java.sql.Timestamp ts = java.sql.Timestamp.valueOf("2020-01-01 00:00:00"); + String r = TBoxUDFs.numspanTimestamptzToTbox.call(FLOATSPAN_HEX, ts); + assertNotNull(r, "numspanTimestamptzToTbox must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void numspanTimestamptzToTbox_null_returns_null() throws Exception { + java.sql.Timestamp ts = java.sql.Timestamp.valueOf("2020-01-01 00:00:00"); + assertNull(TBoxUDFs.numspanTimestamptzToTbox.call(null, ts)); + assertNull(TBoxUDFs.numspanTimestamptzToTbox.call(FLOATSPAN_HEX, null)); + } + + // ------------------------------------------------------------------ + // tboxExpandTime + // ------------------------------------------------------------------ + + @Test @Order(8) + void tboxExpandTime_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxExpandTime.call(TBOX_XT_HEX, "1 day"); + assertNotNull(r, "tboxExpandTime must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void tboxExpandTime_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxExpandTime.call(null, "1 day")); + assertNull(TBoxUDFs.tboxExpandTime.call(TBOX_XT_HEX, null)); + } + + // ------------------------------------------------------------------ + // tboxShiftScaleTime + // ------------------------------------------------------------------ + + @Test @Order(10) + void tboxShiftScaleTime_shift_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxShiftScaleTime.call(TBOX_XT_HEX, "1 day", null); + assertNotNull(r, "tboxShiftScaleTime(shift) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(11) + void tboxShiftScaleTime_scale_returns_nonnull() throws Exception { + String r = TBoxUDFs.tboxShiftScaleTime.call(TBOX_XT_HEX, null, "2 days"); + assertNotNull(r, "tboxShiftScaleTime(scale) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void tboxShiftScaleTime_null_stbox_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxShiftScaleTime.call(null, "1 day", null)); + } + + // ------------------------------------------------------------------ + // tboxfloatXmin / tboxfloatXmax + // ------------------------------------------------------------------ + + @Test @Order(13) + void tboxfloatXmin_returns_correct_value() throws Exception { + Double r = TBoxUDFs.tboxfloatXmin.call(TBOX_XT_HEX); + assertNotNull(r, "tboxfloatXmin must return non-null for XT tbox"); + assertEquals(1.5, r, 1e-9); + } + + @Test @Order(14) + void tboxfloatXmax_returns_correct_value() throws Exception { + Double r = TBoxUDFs.tboxfloatXmax.call(TBOX_XT_HEX); + assertNotNull(r, "tboxfloatXmax must return non-null for XT tbox"); + assertEquals(9.5, r, 1e-9); + } + + @Test @Order(15) + void tboxfloatXmin_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxfloatXmin.call(null)); + } + + // ------------------------------------------------------------------ + // tboxintXmin / tboxintXmax + // ------------------------------------------------------------------ + + @Test @Order(16) + void tboxintXmin_returns_correct_value() throws Exception { + Integer r = TBoxUDFs.tboxintXmin.call(TBOX_INT_HEX); + assertNotNull(r, "tboxintXmin must return non-null for integer tbox"); + assertEquals(1, r); + } + + @Test @Order(17) + void tboxintXmax_returns_correct_value() throws Exception { + Integer r = TBoxUDFs.tboxintXmax.call(TBOX_INT_HEX); + assertNotNull(r, "tboxintXmax must return non-null for integer tbox"); + assertEquals(9, r); + } + + @Test @Order(18) + void tboxintXmin_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxintXmin.call(null)); + } + + // ------------------------------------------------------------------ + // intersectionTboxTbox / unionTboxTbox + // ------------------------------------------------------------------ + + @Test @Order(19) + void intersectionTboxTbox_overlapping_boxes_returns_nonnull() throws Exception { + String r = TBoxUDFs.intersectionTboxTbox.call(TBOX_XT_HEX, TBOX_XT_HEX); + assertNotNull(r, "intersection of a box with itself must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(20) + void unionTboxTbox_returns_nonnull() throws Exception { + String r = TBoxUDFs.unionTboxTbox.call(TBOX_XT_HEX, TBOX_XT_HEX); + assertNotNull(r, "union of a box with itself must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(21) + void intersectionTboxTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.intersectionTboxTbox.call(null, TBOX_XT_HEX)); + assertNull(TBoxUDFs.intersectionTboxTbox.call(TBOX_XT_HEX, null)); + } + + @Test @Order(22) + void unionTboxTbox_null_returns_null() throws Exception { + assertNull(TBoxUDFs.unionTboxTbox.call(null, TBOX_XT_HEX)); + } + + // ------------------------------------------------------------------ + // TBox positional predicates + // ------------------------------------------------------------------ + + @Test @Order(23) + void tboxLeft_x_left_of_high_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxLeft.call(TBOX_XT_HEX, TBOX_HIGH_HEX), + "tbox([1.5,9.5]) is strictly left of tbox([100,200])"); + } + + @Test @Order(24) + void tboxRight_high_box_right_of_x_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxRight.call(TBOX_HIGH_HEX, TBOX_XT_HEX), + "tbox([100,200]) is strictly right of tbox([1.5,9.5])"); + } + + @Test @Order(25) + void tboxBefore_xt_before_future_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxBefore.call(TBOX_XT_HEX, TBOX_FUTURE_HEX), + "tbox ending 2020-01-03 is before tbox starting 2020-01-10"); + } + + @Test @Order(26) + void tboxAfter_future_after_xt_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxAfter.call(TBOX_FUTURE_HEX, TBOX_XT_HEX), + "tbox starting 2020-01-10 is after tbox ending 2020-01-03"); + } + + @Test @Order(27) + void tboxLeft_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxLeft.call(null, TBOX_XT_HEX)); + assertNull(TBoxUDFs.tboxLeft.call(TBOX_XT_HEX, null)); + } + + // ------------------------------------------------------------------ + // TBox topology predicates + // ------------------------------------------------------------------ + + @Test @Order(28) + void tboxContains_same_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxContains.call(TBOX_XT_HEX, TBOX_XT_HEX), + "a tbox contains itself"); + } + + @Test @Order(29) + void tboxContained_same_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxContained.call(TBOX_XT_HEX, TBOX_XT_HEX), + "a tbox is contained in itself"); + } + + @Test @Order(30) + void tboxOverlaps_same_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxOverlaps.call(TBOX_XT_HEX, TBOX_XT_HEX), + "a tbox overlaps itself"); + } + + @Test @Order(31) + void tboxContains_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxContains.call(null, TBOX_XT_HEX)); + assertNull(TBoxUDFs.tboxContains.call(TBOX_XT_HEX, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExtTest.java new file mode 100644 index 00000000..2d408958 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsExtTest.java @@ -0,0 +1,84 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TBoxUDFs rounding: tboxRound. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TBoxUDFsExtTest { + + private static String TBOX_HEX; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + // Build a tbox via tnumber_to_tbox from a tfloat sequence with non-trivial values + TBOX_HEX = AccessorUDFs.tnumberToTbox.call( + temporal_as_hexwkb(tfloat_in("[1.123456@2020-01-01, 9.987654@2020-01-03]"), (byte) 0)); + } + + @Test @Order(1) + void tboxRound_returns_nonnull_hexwkb() throws Exception { + assertNotNull(TBOX_HEX, "TBOX must be buildable"); + String r = TBoxUDFs.tboxRound.call(TBOX_HEX, 2); + assertNotNull(r, "tboxRound must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tboxRound_xmin_is_rounded() throws Exception { + String rounded = TBoxUDFs.tboxRound.call(TBOX_HEX, 2); + assertNotNull(rounded); + Double xmin = TBoxUDFs.tboxXmin.call(rounded); + assertNotNull(xmin); + assertEquals(1.12, xmin, 1e-9, "xmin rounded to 2 decimals must be 1.12"); + } + + @Test @Order(3) + void tboxRound_xmax_is_rounded() throws Exception { + String rounded = TBoxUDFs.tboxRound.call(TBOX_HEX, 2); + assertNotNull(rounded); + Double xmax = TBoxUDFs.tboxXmax.call(rounded); + assertNotNull(xmax); + assertEquals(9.99, xmax, 1e-9, "xmax rounded to 2 decimals must be 9.99"); + } + + @Test @Order(4) + void tboxRound_null_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxRound.call(null, 2)); + assertNull(TBoxUDFs.tboxRound.call(TBOX_HEX, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsTest.java new file mode 100644 index 00000000..5fe937fd --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TBoxUDFsTest.java @@ -0,0 +1,177 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TBoxUDFs — TBox accessor and span-conversion operations. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TBoxUDFsTest { + + // TBOX XT([1,10],[2020-01-01,2020-01-10]) + private static String TBOX_XT; + // TBOX T([2020-01-01,2020-01-10]) — temporal only + private static String TBOX_T; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TBOX_XT = ConstructorUDFs.tbox.call( + "TBOX XT([1,10],[2020-01-01 00:00:00+00,2020-01-10 00:00:00+00])"); + TBOX_T = ConstructorUDFs.tbox.call( + "TBOX T([2020-01-01 00:00:00+00,2020-01-10 00:00:00+00])"); + } + + // ------------------------------------------------------------------ + // Has-component flags + // ------------------------------------------------------------------ + + @Test @Order(1) + void tboxHasx_xt_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxHasx.call(TBOX_XT)); + } + + @Test @Order(2) + void tboxHasx_t_only_box_returns_false() throws Exception { + assertFalse(TBoxUDFs.tboxHasx.call(TBOX_T)); + } + + @Test @Order(3) + void tboxHast_xt_box_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxHast.call(TBOX_XT)); + } + + // ------------------------------------------------------------------ + // Numeric bound accessors + // ------------------------------------------------------------------ + + @Test @Order(4) + void tboxXmin_returns_one() throws Exception { + Double xmin = TBoxUDFs.tboxXmin.call(TBOX_XT); + assertNotNull(xmin); + assertEquals(1.0, xmin, 1e-9); + } + + @Test @Order(5) + void tboxXmax_returns_ten() throws Exception { + Double xmax = TBoxUDFs.tboxXmax.call(TBOX_XT); + assertNotNull(xmax); + assertEquals(10.0, xmax, 1e-9); + } + + @Test @Order(6) + void tboxXmin_t_only_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxXmin.call(TBOX_T)); + } + + @Test @Order(7) + void tboxXminInc_closed_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxXminInc.call(TBOX_XT)); + } + + @Test @Order(8) + void tboxXmaxInc_closed_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxXmaxInc.call(TBOX_XT)); + } + + // ------------------------------------------------------------------ + // Temporal bound accessors + // ------------------------------------------------------------------ + + @Test @Order(9) + void tboxTmin_returns_2020_01_01() throws Exception { + java.sql.Timestamp ts = TBoxUDFs.tboxTmin.call(TBOX_XT); + assertNotNull(ts); + assertTrue(ts.toString().startsWith("2020-01-01"), + "Expected 2020-01-01, got: " + ts); + } + + @Test @Order(10) + void tboxTmax_returns_2020_01_10() throws Exception { + java.sql.Timestamp ts = TBoxUDFs.tboxTmax.call(TBOX_XT); + assertNotNull(ts); + assertTrue(ts.toString().startsWith("2020-01-10"), + "Expected 2020-01-10, got: " + ts); + } + + @Test @Order(11) + void tboxTminInc_closed_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxTminInc.call(TBOX_XT)); + } + + @Test @Order(12) + void tboxTmaxInc_closed_returns_true() throws Exception { + assertTrue(TBoxUDFs.tboxTmaxInc.call(TBOX_XT)); + } + + // ------------------------------------------------------------------ + // Span conversions + // ------------------------------------------------------------------ + + @Test @Order(13) + void tboxToFloatspan_returns_hex() throws Exception { + String hex = TBoxUDFs.tboxToFloatspan.call(TBOX_XT); + assertNotNull(hex); + assertFalse(hex.isBlank()); + } + + @Test @Order(14) + void tboxToTstzspan_returns_hex() throws Exception { + String hex = TBoxUDFs.tboxToTstzspan.call(TBOX_XT); + assertNotNull(hex); + assertFalse(hex.isBlank()); + } + + @Test @Order(15) + void tboxToFloatspan_t_only_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxToFloatspan.call(TBOX_T)); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(16) + void null_input_returns_null() throws Exception { + assertNull(TBoxUDFs.tboxHasx.call(null)); + assertNull(TBoxUDFs.tboxHast.call(null)); + assertNull(TBoxUDFs.tboxXmin.call(null)); + assertNull(TBoxUDFs.tboxXmax.call(null)); + assertNull(TBoxUDFs.tboxTmin.call(null)); + assertNull(TBoxUDFs.tboxTmax.call(null)); + assertNull(TBoxUDFs.tboxToFloatspan.call(null)); + assertNull(TBoxUDFs.tboxToTstzspan.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsExt2Test.java new file mode 100644 index 00000000..92cd3b3b --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsExt2Test.java @@ -0,0 +1,183 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TTextUDFs ttext comparison operators. + * + * Each comparison UDF returns a tbool hex-WKB; the start value (decoded via + * AccessorUDFs.tboolStartValue) is used to verify correctness. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TTextUDFsExt2Test { + + /** ttext "hello" as a single instant: used as the right-hand operand. */ + private static String TTEXT_HELLO_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TTEXT_HELLO_HEX = temporal_as_hexwkb( + ttext_in("hello@2020-01-01 00:00:00+00"), (byte) 0); + } + + // ------------------------------------------------------------------ + // text op ttext + // ------------------------------------------------------------------ + + @Test @Order(1) + void teqTextTtext_equal_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.teqTextTtext.call("hello", TTEXT_HELLO_HEX); + assertNotNull(r, "teqTextTtext must return non-null"); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"hello\" = ttext(hello) must be true"); + } + + @Test @Order(2) + void teqTextTtext_different_text_returns_false_tbool() throws Exception { + String r = TTextUDFs.teqTextTtext.call("world", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertFalse(sv, "\"world\" = ttext(hello) must be false"); + } + + @Test @Order(3) + void tneTextTtext_different_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.tneTextTtext.call("world", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"world\" <> ttext(hello) must be true"); + } + + @Test @Order(4) + void tltTextTtext_lesser_text_returns_true_tbool() throws Exception { + // "abc" < "hello" lexicographically + String r = TTextUDFs.tltTextTtext.call("abc", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"abc\" < ttext(hello) must be true"); + } + + @Test @Order(5) + void tleTextTtext_equal_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.tleTextTtext.call("hello", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"hello\" <= ttext(hello) must be true"); + } + + @Test @Order(6) + void tgtTextTtext_greater_text_returns_true_tbool() throws Exception { + // "xyz" > "hello" lexicographically + String r = TTextUDFs.tgtTextTtext.call("xyz", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"xyz\" > ttext(hello) must be true"); + } + + @Test @Order(7) + void tgeTextTtext_equal_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.tgeTextTtext.call("hello", TTEXT_HELLO_HEX); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "\"hello\" >= ttext(hello) must be true"); + } + + @Test @Order(8) + void teqTextTtext_null_returns_null() throws Exception { + assertNull(TTextUDFs.teqTextTtext.call(null, TTEXT_HELLO_HEX)); + assertNull(TTextUDFs.teqTextTtext.call("hello", null)); + } + + // ------------------------------------------------------------------ + // ttext op text + // ------------------------------------------------------------------ + + @Test @Order(9) + void teqTtextText_equal_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.teqTtextText.call(TTEXT_HELLO_HEX, "hello"); + assertNotNull(r, "teqTtextText must return non-null"); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) = \"hello\" must be true"); + } + + @Test @Order(10) + void tneTtextText_different_text_returns_true_tbool() throws Exception { + String r = TTextUDFs.tneTtextText.call(TTEXT_HELLO_HEX, "world"); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) <> \"world\" must be true"); + } + + @Test @Order(11) + void tltTtextText_ttext_less_than_text_returns_true_tbool() throws Exception { + // "hello" < "xyz" + String r = TTextUDFs.tltTtextText.call(TTEXT_HELLO_HEX, "xyz"); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) < \"xyz\" must be true"); + } + + @Test @Order(12) + void tleTtextText_equal_returns_true_tbool() throws Exception { + String r = TTextUDFs.tleTtextText.call(TTEXT_HELLO_HEX, "hello"); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) <= \"hello\" must be true"); + } + + @Test @Order(13) + void tgtTtextText_ttext_greater_than_text_returns_true_tbool() throws Exception { + // "hello" > "abc" + String r = TTextUDFs.tgtTtextText.call(TTEXT_HELLO_HEX, "abc"); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) > \"abc\" must be true"); + } + + @Test @Order(14) + void tgeTtextText_equal_returns_true_tbool() throws Exception { + String r = TTextUDFs.tgeTtextText.call(TTEXT_HELLO_HEX, "hello"); + assertNotNull(r); + Boolean sv = AccessorUDFs.tboolStartValue.call(r); + assertTrue(sv, "ttext(hello) >= \"hello\" must be true"); + } + + @Test @Order(15) + void teqTtextText_null_returns_null() throws Exception { + assertNull(TTextUDFs.teqTtextText.call(null, "hello")); + assertNull(TTextUDFs.teqTtextText.call(TTEXT_HELLO_HEX, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsTest.java new file mode 100644 index 00000000..fc6e2817 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TTextUDFsTest.java @@ -0,0 +1,96 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TTextUDFs — ttext case-conversion operations. + * + * Tests run directly against MEOS via JMEOS without a Spark session. + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TTextUDFsTest { + + private static String TTEXT_HELLO; + private static String TTEXT_WORLD; + + @BeforeAll + static void initMeos() throws Exception { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TTEXT_HELLO = temporal_as_hexwkb(ttext_in("hello@2020-01-01"), (byte) 0); + TTEXT_WORLD = temporal_as_hexwkb(ttext_in("World@2020-01-01"), (byte) 0); + } + + @Test @Order(1) + void ttextUpper_converts_to_uppercase() throws Exception { + String upper = TTextUDFs.ttextUpper.call(TTEXT_HELLO); + assertNotNull(upper); + // Decode back and check the start value + String sv = AccessorUDFs.ttextStartValue.call(upper); + assertNotNull(sv); + assertEquals("\"HELLO\"", sv); + } + + @Test @Order(2) + void ttextLower_converts_to_lowercase() throws Exception { + String lower = TTextUDFs.ttextLower.call(TTEXT_WORLD); + assertNotNull(lower); + String sv = AccessorUDFs.ttextStartValue.call(lower); + assertNotNull(sv); + assertEquals("\"world\"", sv); + } + + @Test @Order(3) + void ttextInitcap_capitalises_first_letter() throws Exception { + String init = TTextUDFs.ttextInitcap.call(TTEXT_HELLO); + assertNotNull(init); + String sv = AccessorUDFs.ttextStartValue.call(init); + assertNotNull(sv); + assertEquals("\"Hello\"", sv); + } + + @Test @Order(4) + void ttextUpper_null_input_returns_null() throws Exception { + assertNull(TTextUDFs.ttextUpper.call(null)); + } + + @Test @Order(5) + void ttextLower_null_input_returns_null() throws Exception { + assertNull(TTextUDFs.ttextLower.call(null)); + } + + @Test @Order(6) + void ttextInitcap_null_input_returns_null() throws Exception { + assertNull(TTextUDFs.ttextInitcap.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TemporalCompUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/TemporalCompUDFsTest.java new file mode 100644 index 00000000..457d1146 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TemporalCompUDFsTest.java @@ -0,0 +1,112 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TemporalCompUDFsTest { + + private static String TINT; + private static String TFLOAT; + private static String TBOOL; + private static String TTEXT; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT = temporal_as_hexwkb( + tint_in("[1@2020-01-01 00:00:00+00, 5@2020-01-02 00:00:00+00]"), (byte) 0); + TFLOAT = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01 00:00:00+00, 5.0@2020-01-02 00:00:00+00]"), (byte) 0); + TBOOL = temporal_as_hexwkb( + tbool_in("[true@2020-01-01 00:00:00+00, false@2020-01-02 00:00:00+00]"), (byte) 0); + TTEXT = temporal_as_hexwkb( + ttext_in("[\"a\"@2020-01-01 00:00:00+00, \"b\"@2020-01-02 00:00:00+00]"), (byte) 0); + } + + // teq — one test per type combo + + @Test @Order(1) void teqTintInt() throws Exception { + String r = TemporalCompUDFs.teqTintInt.call(TINT, 3); + assertNotNull(r); assertFalse(r.isBlank()); + } + + @Test @Order(2) void teqTfloatFloat() throws Exception { + assertNotNull(TemporalCompUDFs.teqTfloatFloat.call(TFLOAT, 3.0)); + } + + @Test @Order(3) void teqTboolBool() throws Exception { + assertNotNull(TemporalCompUDFs.teqTboolBool.call(TBOOL, true)); + } + + @Test @Order(4) void teqTtextText() throws Exception { + assertNotNull(TemporalCompUDFs.teqTtextText.call(TTEXT, "a")); + } + + @Test @Order(5) void teqTemporal() throws Exception { + assertNotNull(TemporalCompUDFs.teqTemporal.call(TINT, TINT)); + } + + // tne / tlt / tle / tgt / tge — one representative each + + @Test @Order(6) void tneTintInt() throws Exception { + assertNotNull(TemporalCompUDFs.tneTintInt.call(TINT, 3)); + } + + @Test @Order(7) void tltTfloatFloat() throws Exception { + assertNotNull(TemporalCompUDFs.tltTfloatFloat.call(TFLOAT, 3.0)); + } + + @Test @Order(8) void tleTtextText() throws Exception { + assertNotNull(TemporalCompUDFs.tleTtextText.call(TTEXT, "b")); + } + + @Test @Order(9) void tgtTintInt() throws Exception { + assertNotNull(TemporalCompUDFs.tgtTintInt.call(TINT, 3)); + } + + @Test @Order(10) void tgeTemporal() throws Exception { + assertNotNull(TemporalCompUDFs.tgeTemporal.call(TINT, TINT)); + } + + // null guards + + @Test @Order(11) void teqTintInt_null_returns_null() throws Exception { + assertNull(TemporalCompUDFs.teqTintInt.call(null, 3)); + assertNull(TemporalCompUDFs.teqTintInt.call(TINT, null)); + } + + @Test @Order(12) void teqTemporal_null_returns_null() throws Exception { + assertNull(TemporalCompUDFs.teqTemporal.call(null, TINT)); + assertNull(TemporalCompUDFs.teqTemporal.call(TINT, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TemporalUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/TemporalUDFsExtTest.java new file mode 100644 index 00000000..fc4394e0 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TemporalUDFsExtTest.java @@ -0,0 +1,160 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TemporalUDFs MFJSON output and text-output UDFs: + * temporalAsMfjson, tboolOut, tintOut, tfloatOut, ttextOut. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TemporalUDFsExtTest { + + private static String TRIP_HEX; + private static String TBOOL_HEX; + private static String TINT_HEX; + private static String TFLOAT_HEX; + private static String TTEXT_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TBOOL_HEX = temporal_as_hexwkb(tbool_in("[true@2020-01-01, false@2020-01-03]"), (byte) 0); + TINT_HEX = temporal_as_hexwkb(tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TFLOAT_HEX = temporal_as_hexwkb(tfloat_in("[1.5@2020-01-01, 2.5@2020-01-03]"), (byte) 0); + TTEXT_HEX = temporal_as_hexwkb(ttext_in("[hello@2020-01-01, world@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // temporalAsMfjson + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalAsMfjson_returns_json_string() throws Exception { + String r = TemporalUDFs.temporalAsMfjson.call(TRIP_HEX, 6); + assertNotNull(r); + assertFalse(r.isBlank()); + assertTrue(r.contains("\"type\""), "MFJSON output must be a JSON object"); + } + + @Test @Order(2) + void temporalAsMfjson_null_precision_uses_default() throws Exception { + String r = TemporalUDFs.temporalAsMfjson.call(TRIP_HEX, null); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void temporalAsMfjson_null_trip_returns_null() throws Exception { + assertNull(TemporalUDFs.temporalAsMfjson.call(null, 6)); + } + + // ------------------------------------------------------------------ + // tboolOut + // ------------------------------------------------------------------ + + @Test @Order(4) + void tboolOut_returns_text_representation() throws Exception { + String r = TemporalUDFs.tboolOut.call(TBOOL_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + assertTrue(r.contains("t") || r.contains("f"), "tbool text must contain t or f"); + } + + @Test @Order(5) + void tboolOut_null_returns_null() throws Exception { + assertNull(TemporalUDFs.tboolOut.call(null)); + } + + // ------------------------------------------------------------------ + // tintOut + // ------------------------------------------------------------------ + + @Test @Order(6) + void tintOut_returns_text_representation() throws Exception { + String r = TemporalUDFs.tintOut.call(TINT_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + assertTrue(r.contains("1"), "tintOut must contain the value 1"); + } + + @Test @Order(7) + void tintOut_null_returns_null() throws Exception { + assertNull(TemporalUDFs.tintOut.call(null)); + } + + // ------------------------------------------------------------------ + // tfloatOut + // ------------------------------------------------------------------ + + @Test @Order(8) + void tfloatOut_returns_text_with_decimal_value() throws Exception { + String r = TemporalUDFs.tfloatOut.call(TFLOAT_HEX, 2); + assertNotNull(r); + assertFalse(r.isBlank()); + assertTrue(r.contains("1.5") || r.contains("1.50"), "tfloatOut must contain 1.5"); + } + + @Test @Order(9) + void tfloatOut_null_precision_uses_default() throws Exception { + String r = TemporalUDFs.tfloatOut.call(TFLOAT_HEX, null); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void tfloatOut_null_returns_null() throws Exception { + assertNull(TemporalUDFs.tfloatOut.call(null, 6)); + } + + // ------------------------------------------------------------------ + // ttextOut + // ------------------------------------------------------------------ + + @Test @Order(11) + void ttextOut_returns_text_with_value() throws Exception { + String r = TemporalUDFs.ttextOut.call(TTEXT_HEX); + assertNotNull(r); + assertFalse(r.isBlank()); + assertTrue(r.contains("hello"), "ttextOut must contain the literal value 'hello'"); + } + + @Test @Order(12) + void ttextOut_null_returns_null() throws Exception { + assertNull(TemporalUDFs.ttextOut.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt2Test.java b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt2Test.java new file mode 100644 index 00000000..a4c780f5 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt2Test.java @@ -0,0 +1,126 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for second batch of TransformUDF extensions: + * tintToTfloat, temporalSimplifyMinTdelta, temporalTPrecision, + * and temporalDeleteTstzset (restriction extension). + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TransformUDFsExt2Test { + + private static String TINT_SEQ; + private static String TFLOAT_SEQ; + private static String TSTZSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("[1@2020-01-01, 2@2020-01-02, 3@2020-01-03, 4@2020-01-04, 5@2020-01-05]"), + (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.5@2020-01-01, 2.5@2020-01-03, 3.5@2020-01-05]"), (byte) 0); + TSTZSET_HEX = set_as_hexwkb( + tstzset_in("{2020-01-02 00:00:00+00, 2020-01-04 00:00:00+00}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tintToTfloat + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintToTfloat_returns_tfloat_hex() throws Exception { + String r = TransformUDFs.tintToTfloat.call(TINT_SEQ); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tintToTfloat_value_preserved() throws Exception { + String r = TransformUDFs.tintToTfloat.call(TINT_SEQ); + assertNotNull(r); + Double sv = AccessorUDFs.tfloatStartValue.call(r); + assertNotNull(sv); + assertEquals(1.0, sv, 1e-9); + } + + // ------------------------------------------------------------------ + // temporalSimplifyMinTdelta + // ------------------------------------------------------------------ + + @Test @Order(3) + void temporalSimplifyMinTdelta_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalSimplifyMinTdelta.call(TFLOAT_SEQ, "1 day"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // temporalTPrecision + // ------------------------------------------------------------------ + + @Test @Order(4) + void temporalTPrecision_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalTPrecision.call(TFLOAT_SEQ, "1 day"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // temporalDeleteTstzset (RestrictionUDFs) + // ------------------------------------------------------------------ + + @Test @Order(5) + void temporalDeleteTstzset_removes_instants() throws Exception { + String r = RestrictionUDFs.temporalDeleteTstzset.call(TINT_SEQ, TSTZSET_HEX); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(6) + void null_inputs_return_null() throws Exception { + assertNull(TransformUDFs.tintToTfloat.call(null)); + assertNull(TransformUDFs.temporalSimplifyMinTdelta.call(null, "1 day")); + assertNull(TransformUDFs.temporalSimplifyMinTdelta.call(TFLOAT_SEQ, null)); + assertNull(TransformUDFs.temporalTPrecision.call(null, "1 day")); + assertNull(RestrictionUDFs.temporalDeleteTstzset.call(null, TSTZSET_HEX)); + assertNull(RestrictionUDFs.temporalDeleteTstzset.call(TINT_SEQ, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt3Test.java b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt3Test.java new file mode 100644 index 00000000..3c0fcec0 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt3Test.java @@ -0,0 +1,129 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for tint value-domain shift/scale UDFs: + * tintShiftValue, tintScaleValue, tintShiftScaleValue. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TransformUDFsExt3Test { + + private static String TINT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TINT_SEQ = temporal_as_hexwkb( + tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // tintShiftValue + // ------------------------------------------------------------------ + + @Test @Order(1) + void tintShiftValue_positive_shift_returns_nonnull() throws Exception { + String r = TransformUDFs.tintShiftValue.call(TINT_SEQ, 10); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void tintShiftValue_changes_start_value() throws Exception { + String r = TransformUDFs.tintShiftValue.call(TINT_SEQ, 5); + assertNotNull(r); + Integer sv = AccessorUDFs.tintStartValue.call(r); + assertNotNull(sv); + assertEquals(6, sv.intValue()); + } + + @Test @Order(3) + void tintShiftValue_negative_shift_returns_nonnull() throws Exception { + String r = TransformUDFs.tintShiftValue.call(TINT_SEQ, -1); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void tintShiftValue_null_returns_null() throws Exception { + assertNull(TransformUDFs.tintShiftValue.call(null, 5)); + assertNull(TransformUDFs.tintShiftValue.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // tintScaleValue + // ------------------------------------------------------------------ + + @Test @Order(5) + void tintScaleValue_doubles_start_value() throws Exception { + String r = TransformUDFs.tintScaleValue.call(TINT_SEQ, 2); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void tintScaleValue_by_one_is_identity() throws Exception { + String r = TransformUDFs.tintScaleValue.call(TINT_SEQ, 1); + assertNotNull(r); + Integer sv = AccessorUDFs.tintStartValue.call(r); + assertNotNull(sv); + assertEquals(1, sv.intValue()); + } + + @Test @Order(7) + void tintScaleValue_null_returns_null() throws Exception { + assertNull(TransformUDFs.tintScaleValue.call(null, 2)); + assertNull(TransformUDFs.tintScaleValue.call(TINT_SEQ, null)); + } + + // ------------------------------------------------------------------ + // tintShiftScaleValue + // ------------------------------------------------------------------ + + @Test @Order(8) + void tintShiftScaleValue_shift_then_scale_returns_nonnull() throws Exception { + String r = TransformUDFs.tintShiftScaleValue.call(TINT_SEQ, 1, 3); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void tintShiftScaleValue_null_returns_null() throws Exception { + assertNull(TransformUDFs.tintShiftScaleValue.call(null, 1, 2)); + assertNull(TransformUDFs.tintShiftScaleValue.call(TINT_SEQ, null, 2)); + assertNull(TransformUDFs.tintShiftScaleValue.call(TINT_SEQ, 1, null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt4Test.java b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt4Test.java new file mode 100644 index 00000000..7dba3488 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExt4Test.java @@ -0,0 +1,224 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TransformUDFs set and span transforms: + * floatset (ceil/floor/round/degrees/radians), + * textset (lower/upper/initcap), + * intspan/floatspan shift-scale, + * intspanset/floatspanset shift-scale, ceil, floor, round, type conversions. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TransformUDFsExt4Test { + + private static String FLOATSET_HEX; + private static String TEXTSET_HEX; + private static String INTSPAN_HEX; + private static String FLOATSPAN_HEX; + private static String INTSPANSET_HEX; + private static String FLOATSPANSET_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + FLOATSET_HEX = set_as_hexwkb(floatset_in("{1.1, 2.2, 3.3}"), (byte) 0); + TEXTSET_HEX = set_as_hexwkb(textset_in("{\"apple\", \"BANANA\", \"Cherry\"}"), (byte) 0); + INTSPAN_HEX = span_as_hexwkb(intspan_in("[1, 10]"), (byte) 0); + FLOATSPAN_HEX = span_as_hexwkb(floatspan_in("[1.5, 10.5]"), (byte) 0); + INTSPANSET_HEX = spanset_as_hexwkb(intspanset_in("{[1, 5], [10, 20]}"), (byte) 0); + FLOATSPANSET_HEX = spanset_as_hexwkb(floatspanset_in("{[1.5, 5.5], [10.0, 20.0]}"), (byte) 0); + } + + // ------------------------------------------------------------------ + // floatset transforms + // ------------------------------------------------------------------ + + @Test @Order(1) + void floatsetCeil_returns_nonnull() throws Exception { + String r = TransformUDFs.floatsetCeil.call(FLOATSET_HEX); + assertNotNull(r, "floatsetCeil must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void floatsetFloor_returns_nonnull() throws Exception { + String r = TransformUDFs.floatsetFloor.call(FLOATSET_HEX); + assertNotNull(r, "floatsetFloor must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void floatsetDegrees_returns_nonnull() throws Exception { + String r = TransformUDFs.floatsetDegrees.call(FLOATSET_HEX); + assertNotNull(r, "floatsetDegrees must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(5) + void floatsetRadians_returns_nonnull() throws Exception { + String r = TransformUDFs.floatsetRadians.call(FLOATSET_HEX); + assertNotNull(r, "floatsetRadians must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(6) + void floatsetCeil_null_returns_null() throws Exception { + assertNull(TransformUDFs.floatsetCeil.call(null)); + } + + // ------------------------------------------------------------------ + // textset case normalization + // ------------------------------------------------------------------ + + @Test @Order(7) + void textsetLower_returns_nonnull() throws Exception { + String r = TransformUDFs.textsetLower.call(TEXTSET_HEX); + assertNotNull(r, "textsetLower must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(8) + void textsetUpper_returns_nonnull() throws Exception { + String r = TransformUDFs.textsetUpper.call(TEXTSET_HEX); + assertNotNull(r, "textsetUpper must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(9) + void textsetInitcap_returns_nonnull() throws Exception { + String r = TransformUDFs.textsetInitcap.call(TEXTSET_HEX); + assertNotNull(r, "textsetInitcap must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(10) + void textsetLower_null_returns_null() throws Exception { + assertNull(TransformUDFs.textsetLower.call(null)); + } + + // ------------------------------------------------------------------ + // intspan / floatspan shift-scale + // ------------------------------------------------------------------ + + @Test @Order(11) + void intspanShiftScale_shift_only_returns_nonnull() throws Exception { + String r = TransformUDFs.intspanShiftScale.call(INTSPAN_HEX, 5, null); + assertNotNull(r, "intspanShiftScale (shift only) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(12) + void intspanShiftScale_scale_only_returns_nonnull() throws Exception { + String r = TransformUDFs.intspanShiftScale.call(INTSPAN_HEX, null, 20); + assertNotNull(r, "intspanShiftScale (scale only) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(13) + void intspanShiftScale_null_span_returns_null() throws Exception { + assertNull(TransformUDFs.intspanShiftScale.call(null, 5, 10)); + } + + @Test @Order(14) + void floatspanShiftScale_shift_only_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspanShiftScale.call(FLOATSPAN_HEX, 2.5, null); + assertNotNull(r, "floatspanShiftScale (shift only) must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(15) + void floatspanShiftScale_null_span_returns_null() throws Exception { + assertNull(TransformUDFs.floatspanShiftScale.call(null, 1.0, 5.0)); + } + + // ------------------------------------------------------------------ + // intspanset / floatspanset transforms + // ------------------------------------------------------------------ + + @Test @Order(16) + void intspansetShiftScale_returns_nonnull() throws Exception { + String r = TransformUDFs.intspansetShiftScale.call(INTSPANSET_HEX, 10, null); + assertNotNull(r, "intspansetShiftScale must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(17) + void floatspansetShiftScale_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspansetShiftScale.call(FLOATSPANSET_HEX, 1.0, null); + assertNotNull(r, "floatspansetShiftScale must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(18) + void floatspansetCeil_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspansetCeil.call(FLOATSPANSET_HEX); + assertNotNull(r, "floatspansetCeil must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(19) + void floatspansetFloor_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspansetFloor.call(FLOATSPANSET_HEX); + assertNotNull(r, "floatspansetFloor must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(20) + void floatspansetRound_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspansetRound.call(FLOATSPANSET_HEX, 1); + assertNotNull(r, "floatspansetRound must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(21) + void intspansetToFloat_returns_nonnull() throws Exception { + String r = TransformUDFs.intspansetToFloat.call(INTSPANSET_HEX); + assertNotNull(r, "intspansetToFloat must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(22) + void floatspansetToInt_returns_nonnull() throws Exception { + String r = TransformUDFs.floatspansetToInt.call(FLOATSPANSET_HEX); + assertNotNull(r, "floatspansetToInt must return non-null"); + assertFalse(r.isBlank()); + } + + @Test @Order(23) + void floatspansetCeil_null_returns_null() throws Exception { + assertNull(TransformUDFs.floatspansetCeil.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExtTest.java b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExtTest.java new file mode 100644 index 00000000..2b78a5f9 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsExtTest.java @@ -0,0 +1,119 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for new TransformUDFs — min-distance simplification, + * temporal re-sampling (tSample), and trajectory extraction. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TransformUDFsExtTest { + + private static String TRIP; + private static String TFLOAT_SEQ; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, " + + "POINT(1 0)@2020-01-01 00:15:00+00, " + + "POINT(3 4)@2020-01-01 01:00:00+00]"), + (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb( + tfloat_in("[1.0@2020-01-01, 2.0@2020-01-02, 5.0@2020-01-05]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Min-distance simplification + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalSimplifyMinDist_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalSimplifyMinDist.call(TRIP, 0.1); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalSimplifyMinDist_large_threshold_reduces() throws Exception { + // A very large threshold should collapse the sequence to fewer instants + String r = TransformUDFs.temporalSimplifyMinDist.call(TRIP, 100.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Temporal re-sampling + // ------------------------------------------------------------------ + + @Test @Order(3) + void temporalTSample_linear_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalTSample.call(TFLOAT_SEQ, "1 day", "Linear"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(4) + void temporalTSample_step_returns_nonnull() throws Exception { + String r = TransformUDFs.temporalTSample.call(TFLOAT_SEQ, "1 day", "Step"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Trajectory extraction + // ------------------------------------------------------------------ + + @Test @Order(5) + void tpointTrajectory_returns_linestring_wkt() throws Exception { + String r = TransformUDFs.tpointTrajectory.call(TRIP); + assertNotNull(r); + // A multi-point sequence should produce a LINESTRING + assertTrue(r.toUpperCase().startsWith("LINESTRING"), + "Expected LINESTRING WKT but got: " + r); + } + + // ------------------------------------------------------------------ + // Null-input guards + // ------------------------------------------------------------------ + + @Test @Order(6) + void null_input_returns_null() throws Exception { + assertNull(TransformUDFs.temporalSimplifyMinDist.call(null, 1.0)); + assertNull(TransformUDFs.temporalTSample.call(null, "1 day", "Linear")); + assertNull(TransformUDFs.tpointTrajectory.call(null)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsTest.java b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsTest.java new file mode 100644 index 00000000..c26ba2c8 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/temporal/TransformUDFsTest.java @@ -0,0 +1,193 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.temporal; + +import org.junit.jupiter.api.*; + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for TransformUDFs — subtype conversion, interpolation change, + * type casting, value/time-domain shifting and scaling, SRID assignment, + * coordinate rounding, and trajectory simplification. + * + * MEOS function authority: meos/include/meos.h, meos/include/meos_geo.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TransformUDFsTest { + + private static String TRIP; + private static String TINT_SEQ; + private static String TFLOAT_SEQ; + private static String TFLOAT_STEP; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + + TRIP = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01 00:00:00+00, POINT(1 0)@2020-01-01 01:00:00+00]"), + (byte) 0); + TINT_SEQ = temporal_as_hexwkb(tint_in("[1@2020-01-01, 3@2020-01-03]"), (byte) 0); + TFLOAT_SEQ = temporal_as_hexwkb(tfloat_in("[1.0@2020-01-01, 3.0@2020-01-03]"), (byte) 0); + TFLOAT_STEP = temporal_as_hexwkb( + tfloat_in("Interp=Step;[1.0@2020-01-01, 3.0@2020-01-03]"), (byte) 0); + } + + // ------------------------------------------------------------------ + // Subtype conversion + // ------------------------------------------------------------------ + + @Test @Order(1) + void temporalToTInstant_single_instant_sequence_becomes_instant() throws Exception { + String singleSeq = temporal_as_hexwkb( + tgeompoint_in("[POINT(0 0)@2020-01-01]"), (byte) 0); + String r = TransformUDFs.temporalToTInstant.call(singleSeq); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(2) + void temporalToTSequence_step_to_linear() throws Exception { + String r = TransformUDFs.temporalToTSequence.call(TFLOAT_STEP, "Linear"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(3) + void temporalToTSequenceSet_converts() throws Exception { + String r = TransformUDFs.temporalToTSequenceSet.call(TFLOAT_SEQ, "Linear"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Interpolation change + // ------------------------------------------------------------------ + + @Test @Order(4) + void temporalSetInterp_step_to_linear() throws Exception { + String r = TransformUDFs.temporalSetInterp.call(TFLOAT_STEP, "Linear"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Type casting + // ------------------------------------------------------------------ + + @Test @Order(5) + void tfloatToTint_returns_tint_hexwkb() throws Exception { + // tfloat_to_tint only works on step-interpolated sequences + String r = TransformUDFs.tfloatToTint.call(TFLOAT_STEP); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Value-domain shifting and scaling + // ------------------------------------------------------------------ + + @Test @Order(6) + void tfloatShiftValue_positive() throws Exception { + String r = TransformUDFs.tfloatShiftValue.call(TFLOAT_SEQ, 10.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(7) + void tfloatScaleValue_doubles() throws Exception { + String r = TransformUDFs.tfloatScaleValue.call(TFLOAT_SEQ, 2.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(8) + void tfloatShiftScaleValue() throws Exception { + String r = TransformUDFs.tfloatShiftScaleValue.call(TFLOAT_SEQ, 1.0, 2.0); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Time-domain shifting and scaling + // ------------------------------------------------------------------ + + @Test @Order(9) + void temporalShiftScaleTime() throws Exception { + String r = TransformUDFs.temporalShiftScaleTime.call(TRIP, "01:00:00", "02:00:00"); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Spatial transformations + // ------------------------------------------------------------------ + + @Test @Order(10) + void tpointSetSrid_to_4326() throws Exception { + String r = TransformUDFs.tpointSetSrid.call(TRIP, 4326); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + @Test @Order(11) + void tpointRound_2_digits() throws Exception { + String r = TransformUDFs.tpointRound.call(TRIP, 2); + assertNotNull(r); + assertFalse(r.isBlank()); + } + + // ------------------------------------------------------------------ + // Trajectory simplification + // ------------------------------------------------------------------ + + @Test @Order(12) + void temporalSimplifyDp_returns_nonnull_or_null() throws Exception { + // A 2-point sequence may be returned as-is or simplified to null; + // accept either outcome but never a blank string. + String r = TransformUDFs.temporalSimplifyDp.call(TRIP, 0.001); + assertTrue(r == null || !r.isBlank()); + } + + @Test @Order(13) + void temporalSimplifyMaxDist_returns_nonnull_or_null() throws Exception { + String r = TransformUDFs.temporalSimplifyMaxDist.call(TRIP, 0.001); + assertTrue(r == null || !r.isBlank()); + } + + // ------------------------------------------------------------------ + // Null-input guard + // ------------------------------------------------------------------ + + @Test @Order(14) + void null_input_returns_null() throws Exception { + assertNull(TransformUDFs.tfloatToTint.call(null)); + assertNull(TransformUDFs.tpointSetSrid.call(null, 4326)); + } +} diff --git a/src/test/java/org/mobilitydb/spark/udfs/TemporalUDFsTest.java b/src/test/java/org/mobilitydb/spark/udfs/TemporalUDFsTest.java new file mode 100644 index 00000000..b47106c6 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/udfs/TemporalUDFsTest.java @@ -0,0 +1,117 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2020-2026, Université libre de Bruxelles and MobilityDB + * 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. + * + *****************************************************************************/ + +package org.mobilitydb.spark.udfs; + +import org.junit.jupiter.api.*; +import org.mobilitydb.spark.temporal.TemporalUDFs; + + +import static functions.functions.*; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for temporal (time-axis) UDFs — runs without a Spark session. + * + * Geo-specific UDFs (eIntersects, nearestApproachDistance, eDwithin) are + * covered in {@link org.mobilitydb.spark.geo.GeoUDFsTest}. + * + * MEOS function authority: meos/include/meos.h + */ +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class TemporalUDFsTest { + + private static String TRIP_HEX; + + @BeforeAll + static void initMeos() { + meos_initialize(); + meos_initialize_timezone("UTC"); + TRIP_HEX = temporal_as_hexwkb( + tgeompoint_in("[POINT(0.0 0.0)@2020-01-01 00:00:00+00, POINT(0.1 0.0)@2020-01-01 01:00:00+00]"), + (byte) 0); + } + + @AfterAll + static void finalizeMeos() { + meos_finalize(); + } + + @Test @Order(1) + void atTime_instant_inside_interval_returns_nonnull() throws Exception { + String result = TemporalUDFs.atTime.call(TRIP_HEX, "2020-01-01 00:30:00+00"); + assertNotNull(result, "atTime should return a value inside the trip interval"); + assertFalse(result.isBlank()); + } + + @Test @Order(2) + void atTime_instant_outside_interval_returns_null() throws Exception { + assertNull(TemporalUDFs.atTime.call(TRIP_HEX, "2020-06-01 00:00:00+00"), + "atTime should return null outside the trip interval"); + } + + @Test @Order(3) + void atTime_null_trip_returns_null() throws Exception { + assertNull(TemporalUDFs.atTime.call(null, "2020-01-01 00:30:00+00")); + } + + @Test @Order(4) + void atTime_period_inside_interval_returns_nonnull() throws Exception { + String result = TemporalUDFs.atTime.call(TRIP_HEX, "[2020-01-01 00:00:00+00,2020-01-01 00:30:00+00]"); + assertNotNull(result, "atTime with period should return a value when trip overlaps the period"); + assertFalse(result.isBlank()); + } + + @Test @Order(5) + void atTime_period_outside_interval_returns_null() throws Exception { + assertNull(TemporalUDFs.atTime.call(TRIP_HEX, "[2020-06-01 00:00:00+00,2020-06-01 01:00:00+00]"), + "atTime with period should return null when trip does not overlap the period"); + } + + @Test @Order(6) + void asHexWKB_is_identity_on_hexwkb() throws Exception { + String result = TemporalUDFs.asHexWKB.call(TRIP_HEX); + assertEquals(TRIP_HEX, result, + "asHexWKB(hexwkb) must be a lossless identity: parse then re-serialize"); + } + + @Test @Order(7) + void asHexWKB_null_returns_null() throws Exception { + assertNull(TemporalUDFs.asHexWKB.call(null)); + } + + @Test @Order(8) + void asHexWKB_matches_mbdb_expected() throws Exception { + // Known hex-WKB for [POINT(0 0)@2020-01-01 00:00:00+00, POINT(100 0)@2020-01-01 00:10:00+00] + // Generated from MobilityDB: SELECT asHexWKB(trip) FROM Trips WHERE tripId = 1; + String wkt = "[POINT(0 0)@2020-01-01 00:00:00+00, POINT(100 0)@2020-01-01 00:10:00+00]"; + String hexwkb = temporal_as_hexwkb(tgeompoint_in(wkt), (byte) 0); + String expected = "012E000E02000000030101000000000000000000000000000000000000000060C286073E020001010000000000000000005940000000000000000000A685AA073E0200"; + assertEquals(expected, hexwkb, + "MEOS hex-WKB must match MobilityDB asHexWKB() byte-for-byte"); + // asHexWKB UDF returns the same value + assertEquals(expected, TemporalUDFs.asHexWKB.call(hexwkb)); + } +} diff --git a/tools/scripts/check_license.sh b/tools/scripts/check_license.sh new file mode 100755 index 00000000..43be56dd --- /dev/null +++ b/tools/scripts/check_license.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +# Check that all Java source files have the PostgreSQL License header. + +DIR=$(git rev-parse --show-toplevel) +error=0 + +while IFS= read -r -d '' f; do + if ! grep -q "PostgreSQL License" "$f"; then + echo "Missing license header: $f" + error=1 + fi +done < <(find "$DIR/src/main" "$DIR/src/test" -name "*.java" -print0 2>/dev/null) + +if [ $error -eq 0 ]; then + echo "License check passed." +fi +exit $error