diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml new file mode 100644 index 00000000..caf3893a --- /dev/null +++ b/.github/workflows/maven.yml @@ -0,0 +1,67 @@ +name: Maven CI + +on: + push: + branches: ["**"] + pull_request: + +jobs: + # ── Linux ──────────────────────────────────────────────────────────────────── + linux: + name: Build and test — Linux (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 MEOS build dependencies + run: | + sudo apt-get update -qq + sudo apt-get install -y \ + cmake ninja-build \ + libjson-c-dev libgeos-dev libproj-dev libgsl-dev libh3-dev + + - name: Checkout MobilityDB source (for MEOS build) + uses: actions/checkout@v4 + with: + # Ecosystem pin: the SAME commit the vendored catalog (tools/meos-idl.json) + # and the bundled JMEOS jar are generated against. + repository: estebanzimanyi/MobilityDB + ref: ecosystem-pin-2026-06-15f + path: MobilityDB-src + + - name: Build and install libmeos.so + run: | + # The build dir lives inside MobilityDB-src so the vendored pgtypes headers + # ("../../meos/include/...") resolve against the source tree. + cmake -S MobilityDB-src -B MobilityDB-src/meos-build \ + -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DMEOS=ON \ + -DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON \ + -DH3=ON \ + -DH3_LIBRARY=/usr/lib/x86_64-linux-gnu/libh3.so \ + -DH3_INCLUDE_DIR=/usr/include/h3 + cmake --build MobilityDB-src/meos-build -j + sudo cmake --install MobilityDB-src/meos-build + echo "LD_LIBRARY_PATH=/usr/local/lib" >> "$GITHUB_ENV" + + - name: Install the bundled JMEOS jar into the local repo + # The generator reads this jar's symbols at build time and the UDFs call it at + # runtime (org.jmeos:meos:1.0); it is not on Maven Central. + run: | + mvn -B install:install-file \ + -Dfile=libs/JMEOS.jar \ + -DgroupId=org.jmeos -DartifactId=meos -Dversion=1.0 -Dpackaging=jar + + - name: Build + generate + unit tests + # generate-sources runs the catalog-driven UDF generator; test exercises the + # generated surface against libmeos through JMEOS. + run: mvn -B clean test diff --git a/.gitignore b/.gitignore index fc368f31..5b7a1cbd 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,8 @@ # Maven log/ target/ +tools/__pycache__/ +/target/ +src/main/java/org/mobilitydb/spark/generated/ +hs_err_pid*.log +dependency-reduced-pom.xml diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..af23e8fc --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "berlinmod/suite"] + path = berlinmod/suite + url = https://github.com/estebanzimanyi/berlinmod-portability.git diff --git a/INTEGRATION_NOTES.md b/INTEGRATION_NOTES.md new file mode 100644 index 00000000..f0760e00 --- /dev/null +++ b/INTEGRATION_NOTES.md @@ -0,0 +1,19 @@ +# INTEGRATION BRANCH NOTE — MEOS / JMEOS pin + +`integration/berlinmod-bench` builds against ecosystem pin +**`ecosystem-pin-2026-06-11p`**. + +- **`libs/JMEOS-1.4.jar`** is the canonical JMEOS regen at that pin + (JMEOS PR #19): a single generated `functions.GeneratedFunctions` + surface. The legacy hand-rolled `functions.functions` facade is retired, + and every UDF binds the generated surface directly. +- **`lib/libmeos.so`** is built from the pin with `-DH3=ON` and the + CBUFFER / NPOINT / POSE / RGEO families, so the th3index family is backed + with no build-time special-casing. +- **CI** (`.github/workflows/maven.yml`) builds `libmeos` from the pin on + Linux and macOS (with H3). The Windows job is non-blocking until the + `MEOS_TZDATA_DIR` cmake option lands in the pin (it currently lives only on + the `meos-windows-bootstrap` branch); once folded, Windows repoints to the + pin like the other platforms. + +The full unit suite is green (907/907). diff --git a/README.md b/README.md index 0e2d118c..498cde01 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,14 @@ The MobilityDB project is developed by the Computer & Decision Engineering Depar More information about MobilityDB, including publications, presentations, etc., can be found in the MobilityDB [website](https://mobilitydb.com). +### For contributors and reviewers + +- Reviewing a pull request? See the + [PR Reviewer Guide](doc/contributing/reviewer-guide.md) — tier ranking, + dependency chains and the standards checklist. Reviewers landing in + any of the three platform repos (MobilityDB / MobilityDuck / + MobilitySpark) find the same canonical structure at the same path. + ## Table of Contents @@ -40,7 +48,7 @@ More information about MobilityDB, including publications, presentations, etc., - 🚀 MobilityDB installed with MEOS - 🔧 JMEOS working version -- ⚡ Spark 3.4.0 +- ⚡ Apache Spark 3.5.x (LTS); see [`doc/spark-version.md`](doc/spark-version.md) for the Spark-version target and the rationale for not yet supporting Spark 4 - 📝 Maven 4 - ☕ Java 17 (recommended) diff --git a/berlinmod/README.md b/berlinmod/README.md new file mode 100644 index 00000000..f10758df --- /dev/null +++ b/berlinmod/README.md @@ -0,0 +1,102 @@ +# BerlinMOD benchmark — MobilitySpark + +This directory benchmarks the **canonical portable BerlinMOD suite** on +Apache Spark via MobilitySpark's MEOS-backed UDFs. + +The queries, schema, and load script are **not** kept here — they live in the +single canonical source, vendored as the `suite/` git submodule +([`berlinmod-portability`](https://github.com/estebanzimanyi/berlinmod-portability), +shared byte-for-byte with MobilityDB and MobilityDuck). This directory holds +only the Spark-side runner, the data corpus, and the expected results. + +``` +berlinmod/ + suite/ # submodule — the ONE canonical SQL (q01..q17, qrt, schema.sql, + # portable_aliases.sql, data/load.sql) + data/ # CSV corpus loaded into Spark + expected/ # expected query results for correctness checks + bench/ # bench_mspark.sh (timing), report.py, chart.py + run_mspark.sh # correctness demo runner +``` + +After cloning, initialise the submodule: + +```bash +git submodule update --init berlinmod/suite +``` + +--- + +## Running + +**Timing benchmark** (`BerlinMODBench` — reads every query from `suite/`): + +```bash +berlinmod/bench/bench_mspark.sh --data berlinmod/data --output bench/results/mspark.json +# --quick = 1 run/query, --queries q05,q10 to select, --runs N to repeat +``` + +The runner sets `-Dberlinmod.sql.dir=berlinmod/suite`, so every query is read +from the canonical submodule — there is no Spark-specific query variant and no +SQL rewriting. + +**Benchmark runner** (`BerlinMODBench` — canonical berlinmod/suite queries + shared CSV data): + +```bash +berlinmod/run_mspark.sh [spark-submit-binary] +``` + +--- + +## Spatial joins on Spark + +Spark SQL has **no native spatial index**. The canonical queries pre-filter +spatial joins with the bounding-box `&&` operator, which PostgreSQL (GiST) and +DuckDB (TRTREE) accelerate with a spatial index. Spark cannot — it evaluates +`&&` as an opaque UDF, so the index-less spatial joins **q10 / q11 / q12 / q14** +degrade to a Cartesian product with a per-pair MEOS UDF (each call re-parses the +trajectory from hex). On the full corpus these exceed any reasonable per-query +budget; bound them with the caller's own `timeout`. + +The route to timings comparable to the indexed engines is the **th3index +columnar prefilter**: explode each trip's th3index into one row per H3 cell and +turn the overlap into an **equi-join on the cell column**, which Spark +accelerates natively (hash join) — pruning candidate pairs before the exact +`tDwithin`/`eDwithin` runs. th3index is portable (PG/DuckDB/Spark all compute it +from the same MEOS function), so it is the Tier-1 acceleration all three share. + +--- + +## Data + +`data/` holds the BerlinMOD corpus (`trips.csv` is git-ignored — it is large and +regenerated). The CSVs are produced 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 +-- args: path, H3 resolution, output SRID (3812 = ETRS89/Belgian Lambert 2008, +-- Brussels — true metres; the export reprojects + SRID-tags everything here so +-- no consumer ever reprojects) +SELECT berlinmod_portability_export('/path/to/output/', 7, 3812); +``` + +This single call writes the complete dataset (`vehicles.csv`, `trips.csv` with +hex-EWKB trips, `query_licences/instants/points/periods/regions.csv`) in the +schema defined by `suite/schema.sql`. Drop them into `data/` and re-run — there +is no per-tool post-processing. + +--- + +## Cross-engine comparison + +Each tool benchmarks itself and emits a results JSON. The cross-engine +comparison is assembled **offline** by merging the per-tool JSONs: + +```bash +# Collect mspark.json (here) + mbdb.json / mduck.json (from those repos) into one dir, then: +python3 bench/report.py --results --output /report.md +python3 bench/chart.py --results --output /chart.png --log # --log: Spark spatial joins span orders of magnitude +``` 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..c3bc8830 --- /dev/null +++ b/berlinmod/bench/README.md @@ -0,0 +1,56 @@ +# MobilitySpark BerlinMOD benchmark runner + +Times the canonical BerlinMOD suite on Apache Spark. The queries come from the +`berlinmod/suite/` submodule (the single canonical source); see +[`../README.md`](../README.md) for context. + +--- + +## Prerequisites + +```bash +# Apache Spark 3.5.4 (~300 MB) + Maven +sudo apt-get install maven +bash ../../setup/install_spark.sh +source ~/.bashrc + +# Build the fat JAR (once, or after code changes) +cd ../.. && mvn package -DskipTests -q +``` + +## Run + +```bash +# Full corpus, 3 runs/query, data from berlinmod/data/ +bash bench_mspark.sh --data ../data --runs 3 --output results/mspark.json + +# 1 run/query; select queries +bash bench_mspark.sh --data ../data --quick --queries q05,q10 +``` + +All queries run in a single `spark-submit` session (class `BerlinMODBench`); +JVM startup is excluded from query timings. The runner reads every query from +`berlinmod/suite/` — no Spark-specific variant. The index-less spatial joins +(q10/q11/q12/q14) can exceed a per-query budget on the full corpus; wrap the +call in `timeout` to bound them (see `../README.md`, "Spatial joins on Spark"). + +## Cross-engine comparison (offline) + +Each tool emits its own `*.json`. To build a comparison table/chart, collect +`mspark.json` here together with `mbdb.json` / `mduck.json` from those repos +into one directory, then merge offline: + +```bash +python3 report.py --results --output /report.md +python3 chart.py --results --output /chart.png --log +``` + +`chart.py` requires `matplotlib`. `--log` is advisable since Spark's spatial +joins span several orders of magnitude. + +## Methodology + +- **Timing**: wall-clock milliseconds around each query, median of N runs; data + loading excluded. +- **SQL**: the identical canonical `.sql` from `berlinmod/suite/` — + named-function portable dialect, no operator symbols. diff --git a/berlinmod/bench/bench_mspark.sh b/berlinmod/bench/bench_mspark.sh new file mode 100755 index 00000000..00309181 --- /dev/null +++ b/berlinmod/bench/bench_mspark.sh @@ -0,0 +1,133 @@ +#!/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) +# +# Tier: +# Spark always runs the BerlinMOD benchmark at TIER 1 (the th3index +# columnar prefilter is the only common-denominator acceleration that +# Spark can use; native spatial indexes are PG/Duck-only). See +# ../README.md "Three-tier index framework" for context. No --tier +# flag is exposed on this runner. +# +# Spatial-join queries (Q10/Q11/Q12/Q14): +# Every engine runs the identical canonical `.sql` from the +# berlinmod/suite submodule — one source, no Spark-specific variant. +# PG / DuckDB accelerate the bounding-box `&&` pre-filter with a native +# spatial index; Spark has none, so these index-less spatial joins +# evaluate as a Cartesian product with a per-pair MEOS UDF and can +# exceed a per-query time budget. Bound them with the caller's own +# `timeout`, or load the th3index columnar prefilter so the overlap +# becomes an equi-join on H3 cells (the only acceleration Spark shares). +# +# 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} -Dberlinmod.sql.dir=${BERLINMOD_DIR}/suite -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/chart.py b/berlinmod/bench/chart.py new file mode 100644 index 00000000..e1e4513b --- /dev/null +++ b/berlinmod/bench/chart.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python3 +""" +BerlinMOD cross-platform / cross-tier bar chart generator. + +Reads the same JSON result files as report.py and emits a grouped bar +chart (queries × (platform, tier) configurations) as a PNG image. The +output is publishable as-is in Discussions, README, or papers. + +Tier-1 Spark results are shown separately from Tier 3 (PG / Duck only) so +the reader can see the contribution of platform-native indexing. + +Usage: + chart.py --results DIR [--output FILE.png] [--log] [--width N] [--height N] + +Reads: DIR/mbdb.tier{1,2,3}.json, DIR/mduck.tier{1,2,3}.json, + DIR/mspark.tier1.json (any subset). Falls back to legacy + DIR/mbdb.json / mduck.json / mspark.json (treated as Tier 3 / Tier 1). +Writes: FILE.png (default: DIR/chart.png). Requires matplotlib. + +Companion: report.py emits the same data as a markdown table. Run both +to publish the full benchmark artefact. +""" + +import argparse +import json +import statistics +import sys +from pathlib import Path + + +# Canonical query order — keep in sync with report.py +QUERY_ORDER = [ + "q01", "q02", "q03", "q04", "q05", "q06", "q07", "q08", "qrt", + "q09", "q10", "q11", "q12", "q13", "q14", "q15", "q16", "q17", +] + +# Per-platform colour family. Tier shading inside each family +# (Tier 1 = lightest, Tier 3 = darkest) so the eye groups by platform +# first, tier second. +PLATFORM_COLORS = { + "mobilitydb": {1: "#9ec3ff", 2: "#4d8ff5", 3: "#0f4ec9"}, + "mobilityduck": {1: "#ffd28a", 2: "#f7a942", 3: "#c47000"}, + "mobilityspark": {1: "#a3d9a5", 2: "#5fb764", 3: "#1f7a23"}, +} + +PLATFORM_DISPLAY = { + "mobilitydb": "MobilityDB", + "mobilityduck": "MobilityDuck", + "mobilityspark": "MobilitySpark", +} + + +def load_results(results_dir: Path) -> dict: + """Same loader contract as report.load_results — duplicated here so + chart.py has no Python import of report.py (keeps the two tools + independent).""" + platforms = {} + for prefix, key in [("mbdb", "mobilitydb"), + ("mduck", "mobilityduck"), + ("mspark", "mobilityspark")]: + tier_files = sorted(results_dir.glob(f"{prefix}.tier*.json")) + if tier_files: + tiered = {} + for path in tier_files: + with open(path) as f: + data = json.load(f) + tier = int(data.get("tier", 3)) + tiered[tier] = data + platforms[key] = tiered + continue + path = results_dir / f"{prefix}.json" + if path.exists(): + with open(path) as f: + data = json.load(f) + tier = int(data.get("tier", 3)) + platforms[key] = {tier: data} + return platforms + + +def median_ms(times: list[int]) -> float: + return statistics.median(times) + + +def build_chart(platforms: dict, output_path: Path, + width: float, height: float, log: bool) -> None: + try: + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + except ImportError: + print("ERROR: chart.py requires matplotlib. Install with: " + "pip install matplotlib", file=sys.stderr) + sys.exit(2) + import numpy as np + + # Build the list of (platform, tier) columns in stable order so the + # bar groups read MobilityDB → MobilityDuck → MobilitySpark, and within + # each platform Tier 1 → Tier 2 → Tier 3. + columns = [] + for key in ["mobilitydb", "mobilityduck", "mobilityspark"]: + if key not in platforms: + continue + for tier in sorted(platforms[key].keys()): + columns.append((key, tier)) + + if not columns: + print("ERROR: no result data found — nothing to chart.", file=sys.stderr) + sys.exit(1) + + # Per-query median timing for each column + # Only include queries that have at least one column with data + queries_with_data = [] + series = {col: [] for col in columns} + for q in QUERY_ORDER: + any_data = False + for col in columns: + key, tier = col + times = platforms[key][tier].get("queries", {}).get(q) + if times: + series[col].append(median_ms(times)) + any_data = True + else: + series[col].append(float("nan")) + if any_data: + queries_with_data.append(q) + else: + for col in columns: + series[col].pop() + + n_queries = len(queries_with_data) + n_columns = len(columns) + bar_w = 0.8 / max(n_columns, 1) + x = np.arange(n_queries) + + fig, ax = plt.subplots(figsize=(width, height)) + + for i, col in enumerate(columns): + key, tier = col + offsets = x - 0.4 + (i + 0.5) * bar_w + color = PLATFORM_COLORS[key][tier] + label = f"{PLATFORM_DISPLAY[key]} T{tier}" + # Only show platform name once per platform if all tiers present + ax.bar(offsets, series[col], bar_w, label=label, color=color, + edgecolor="white", linewidth=0.5) + + ax.set_xticks(x) + ax.set_xticklabels([q.upper() for q in queries_with_data], rotation=45, + ha="right") + ax.set_ylabel("Median wall-clock (ms)" + + (" — log scale" if log else "")) + ax.set_title("BerlinMOD Portable SQL — Cross-Platform Benchmark") + ax.set_axisbelow(True) + ax.grid(axis="y", linestyle="--", alpha=0.5) + if log: + ax.set_yscale("log") + ax.legend(loc="best", ncol=min(n_columns, 3), fontsize="small", + framealpha=0.85) + + fig.tight_layout() + output_path.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(output_path, dpi=150) + print(f"Chart written to {output_path}") + + +def main(): + parser = argparse.ArgumentParser( + description="BerlinMOD benchmark bar chart generator") + parser.add_argument("--results", default="results", + help="Directory containing mbdb/mduck/mspark JSON files") + parser.add_argument("--output", default=None, + help="Output PNG path (default: /chart.png)") + parser.add_argument("--log", action="store_true", + help="Use logarithmic y-axis " + "(useful when Spark NxN queries dominate the scale)") + parser.add_argument("--width", type=float, default=14.0, + help="Figure width in inches (default: 14)") + parser.add_argument("--height", type=float, default=6.0, + help="Figure height in inches (default: 6)") + args = parser.parse_args() + + results_dir = Path(args.results) + output_path = Path(args.output) if args.output else results_dir / "chart.png" + + platforms = load_results(results_dir) + build_chart(platforms, output_path, args.width, args.height, args.log) + + +if __name__ == "__main__": + main() diff --git a/berlinmod/bench/report.py b/berlinmod/bench/report.py new file mode 100644 index 00000000..ec10a878 --- /dev/null +++ b/berlinmod/bench/report.py @@ -0,0 +1,285 @@ +#!/usr/bin/env python3 +""" +BerlinMOD cross-platform benchmark report generator. + +Reads per-tool JSON result files (mbdb.json / mduck.json / mspark.json — any +subset, each emitted by its own repo's bench runner), collects machine +specifications, and writes a self-contained markdown comparison 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[int, dict]]: + """Load results JSON files. Recognises two layouts: + + 1. Single-tier per platform — `mbdb.json`, `mduck.json`, `mspark.json` + (legacy, pre-3-tier-framework). The tier field defaults to 3 (the + old loader-default behaviour). + 2. Per-tier per platform — `mbdb.tier1.json`, `mbdb.tier2.json`, + `mbdb.tier3.json`, `mduck.tier{1,2,3}.json`, `mspark.tier1.json`. + + Returns: ``{platform_key: {tier_int: result_dict, ...}}``. + """ + platforms: dict[str, dict[int, dict]] = {} + for prefix, key in [("mbdb", "mobilitydb"), + ("mduck", "mobilityduck"), + ("mspark", "mobilityspark")]: + # Per-tier files first (preferred 3-tier framework layout) + tier_files = sorted(results_dir.glob(f"{prefix}.tier*.json")) + if tier_files: + tiered: dict[int, dict] = {} + for path in tier_files: + with open(path) as f: + data = json.load(f) + tier = int(data.get("tier", 3)) + tiered[tier] = data + platforms[key] = tiered + continue + # Legacy single-file layout + path = results_dir / f"{prefix}.json" + if path.exists(): + with open(path) as f: + data = json.load(f) + tier = int(data.get("tier", 3)) + platforms[key] = {tier: 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 — emit one row per (platform, tier) + lines.append("### Platforms") + lines.append("") + lines.append("| Platform | Tier | 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 + for tier in sorted(platforms[key].keys()): + d = platforms[key][tier] + lines.append( + f"| {DISPLAY[key]} | {tier} | {d.get('version','?')} " + f"| {d.get('data_vehicles','?')} " + f"| {d.get('data_trips','?')} " + f"| {d.get('runs','?')} |" + ) + lines.append("") + + # Flatten (platform, tier) into column keys so each column is one + # configuration. For each column we still use the platform's DISPLAY + # name plus a tier suffix when more than one tier is present for that + # platform — keeps the table compact when only Tier 3 (default) data + # exists. + columns: list[tuple[str, int, str]] = [] # (key, tier, header_label) + for key in ["mobilitydb", "mobilityduck", "mobilityspark"]: + if key not in platforms: + continue + tiers = sorted(platforms[key].keys()) + for tier in tiers: + label = DISPLAY[key] + if len(tiers) > 1: + label = f"{label} T{tier}" + columns.append((key, tier, label)) + + lines.append("### Query Timings (median wall-clock)") + lines.append("") + lines.append("| Query | Description |" + "".join( + f" {col_label} |" for _, _, col_label in columns)) + lines.append("|---|---|" + "---|" * len(columns)) + + all_queries = list(QUERY_LABELS.keys()) + for q in all_queries: + cells: list[str] = [] + any_data = False + for key, tier, _ in columns: + times = platforms[key].get(tier, {}).get("queries", {}).get(q) + if times: + cells.append(fmt_ms(median_ms(times))) + any_data = True + else: + cells.append("—") + if not any_data: + continue + label = QUERY_LABELS.get(q, q) + lines.append(f"| `{q}` | {label} | " + " | ".join(cells) + " |") + + 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("Collect each tool's bench JSON (mbdb/mduck/mspark.json) here 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/.gitignore b/berlinmod/data/.gitignore new file mode 100644 index 00000000..a0408976 --- /dev/null +++ b/berlinmod/data/.gitignore @@ -0,0 +1,4 @@ +# The BerlinMOD corpus is produced by the single canonical generator +# (setup/generate_data.sh -> MobilityDB-BerlinMOD berlinmod_portability_export). +# It is NEVER committed — a per-tool committed copy drifts (e.g. wrong SRID). +*.csv 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/run_mspark.sh b/berlinmod/run_mspark.sh new file mode 100755 index 00000000..76d86ac7 --- /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 BerlinMODBench +# 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.BerlinMODBench \\" + 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.BerlinMODBench \\" + 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.BerlinMODBench \ + --master "local[2]" \ + --conf "spark.driver.extraJavaOptions=-Djava.library.path=${LIBMEOS_DIR}" \ + "$JAR" \ + "$DATA_DIR" \ + "$EXPECTED_DIR" diff --git a/berlinmod/spark-dialect/q05.sql b/berlinmod/spark-dialect/q05.sql new file mode 100644 index 00000000..98fc7f66 --- /dev/null +++ b/berlinmod/spark-dialect/q05.sql @@ -0,0 +1,15 @@ +-- Spark-dialect override of q05 (see BerlinMODBench): array_agg -> collect_list +-- (no ordered aggregate needed here); minDistance is the scalar array UDF. Same +-- MEOS computation and result as the canonical q05. +WITH LicenceTrips AS ( + SELECT l.licenceId, l.licence, collect_list(t.trip) AS trips + FROM QueryLicences l + JOIN Vehicles v ON v.licence = l.licence + JOIN Trips t ON t.vehId = v.vehId + GROUP BY l.licenceId, l.licence +) +SELECT a.licence AS licence1, b.licence AS licence2, + minDistance(a.trips, b.trips) AS min_dist +FROM LicenceTrips a +JOIN LicenceTrips b ON a.licenceId < b.licenceId +ORDER BY licence1, licence2; diff --git a/berlinmod/spark-dialect/q06.sql b/berlinmod/spark-dialect/q06.sql new file mode 100644 index 00000000..e5ccc963 --- /dev/null +++ b/berlinmod/spark-dialect/q06.sql @@ -0,0 +1,20 @@ +-- Spark-dialect override of q06: collect ONE sorted struct array (array_sort orders +-- by the first field tripId, giving the parallel-array consistency PG gets from +-- array_agg(... ORDER BY tripId)), transform to parallel arrays, then LATERAL VIEW +-- explode the eDwithinPairs array. 0-based indices into 0-based arrays. +WITH Raw AS ( + SELECT array_sort(collect_list(named_struct( + 'k', t.tripId, 'trip', t.trip, 'licence', v.licence, 'vehId', v.vehId))) AS rows + FROM Vehicles v JOIN Trips t ON t.vehId = v.vehId + WHERE v.type = 'truck' +), +Trucks AS ( + SELECT rows.trip AS trips, + rows.licence AS licences, + rows.vehId AS vehIds + FROM Raw +) +SELECT k.licences[p.i] AS licence1, k.licences[p.j] AS licence2 +FROM Trucks k LATERAL VIEW explode(eDwithinPairs(k.trips, k.trips, 10.0)) _t AS p +WHERE k.vehIds[p.i] < k.vehIds[p.j] +ORDER BY licence1, licence2; diff --git a/berlinmod/spark-dialect/q10.sql b/berlinmod/spark-dialect/q10.sql new file mode 100644 index 00000000..5130a960 --- /dev/null +++ b/berlinmod/spark-dialect/q10.sql @@ -0,0 +1,24 @@ +-- Spark-dialect override of q10: same struct-collect/sort/transform per side, then +-- LATERAL VIEW explode the tDwithinPairs array>. +WITH SelRaw AS ( + SELECT array_sort(collect_list(named_struct( + 'k', t.tripId, 'trip', t.trip, 'licence', l.licence, 'vehId', v.vehId))) AS rows + FROM QueryLicences l JOIN Vehicles v ON v.licence = l.licence + JOIN Trips t ON t.vehId = v.vehId +), +Sel AS ( + SELECT rows.trip AS trips, rows.licence AS licences, + rows.vehId AS vehIds, rows.k AS tripIds FROM SelRaw +), +AllRaw AS ( + SELECT array_sort(collect_list(named_struct('k', t.tripId, 'trip', t.trip, 'vehId', t.vehId))) AS rows + FROM Trips t +), +AllTrips AS ( + SELECT rows.trip AS trips, rows.vehId AS vehIds, + rows.k AS tripIds FROM AllRaw +) +SELECT s.licences[p.i] AS licence1, a.vehIds[p.j] AS car2Id, p.periods AS periods +FROM Sel s, AllTrips a LATERAL VIEW explode(tDwithinPairs(s.trips, a.trips, 3.0)) _t AS p +WHERE s.vehIds[p.i] <> a.vehIds[p.j] +ORDER BY licence1, car2Id, s.tripIds[p.i], a.tripIds[p.j]; diff --git a/berlinmod/suite b/berlinmod/suite new file mode 160000 index 00000000..3ef7ded5 --- /dev/null +++ b/berlinmod/suite @@ -0,0 +1 @@ +Subproject commit 3ef7ded5a072cfd98b32e1bfbfe7c317984bb94c diff --git a/doc/contributing/reviewer-guide.md b/doc/contributing/reviewer-guide.md new file mode 100644 index 00000000..1dd319d3 --- /dev/null +++ b/doc/contributing/reviewer-guide.md @@ -0,0 +1,129 @@ + + +# MobilitySpark PR Reviewer Guide + +Quick reference for anyone reviewing open pull requests in **MobilitySpark** and its JMEOS dependency. +Updated in the same commit as any PR that changes PR state or adds new branches. +**Last updated: 2026-05-11 — PR #9 extended to 86 UDFs (100% `meos_h3.h` parity) and the portable q02.sql polygon-side prefilter via MobilityDB PR #938 (`geo_to_h3index_set`). All three coordinated PRs source-complete (MobilityDB #938, MobilityDB-BerlinMOD #24, this PR #9); awaiting upstream th3index merge + JMEOS regen.** + +--- + +## How to find this guide + +- **In the repo:** `doc/contributing/reviewer-guide.md` +- **Rule:** every commit that opens, closes, or restructures a PR must update this file in the same commit. A one-liner status change is enough; a fuller rewrite is needed when the dependency graph changes. + +--- + +## CI legend + +| Symbol | Meaning | +|--------|---------| +| ✅ | All checks green | +| ❌ | Real failure — needs investigation before review | +| ⏳ | CI running | +| ❓ | No CI result yet (doc-only, draft, or external PR) | +| ⚠️ | Non-blocking failure (e.g. macOS/Windows `continue-on-error`, Codacy ACTION_REQUIRED — maintainer overrides in UI) | + +--- + +## Dependency chains — land in this order + +``` +MobilityDB/MobilityDB + PR #807 / #866 / #893 th3index temporal H3-cell index type + └─► JMEOS regen against MEOS 1.4 master (parallel-session work) + └─► MobilityDB/MobilitySpark + PR #9 perf/spark-mt-and-binary (th3index spatial prefilter — Stage-2 of perf) + +MobilityDB/JMEOS + PR #9 JashanReel:fix-tests-using-docker (multi-module Maven layout; needs cleanup review) + └─► PR #12 estebanzimanyi:fix/multimodule-with-split-interface (split JNR-FFI → ARM64/macOS fix) + └─► MobilityDB/MobilitySpark + PR #7 fix/license-main-java (multi-platform CI bootstrap — stacks on JMEOS above) + └─► PR #5 feat/jmeos-1.3-berlinmod-poc (JMEOS 1.4 + BerlinMOD + 99.3% parity) + └─► PR #8 doc/reviewer-guide (this guide — independent, mergeable any time) +``` + +**PR #11** (`estebanzimanyi:fix/split-meos-library-interface`) was superseded by +`fix/multimodule-with-split-interface` (#12) and **closed 2026-05-10** as part of the +MobilitySpark consolidation pass. + +**PR #8** (`SachaDelsaux:JMEOS_v1.3`) is subsumed by PR #9 — external author; recommended for +closure but left in place pending author signal. + +--- + +## Tier 1 — Merge immediately (visibility / trivially reviewable) + +| Repo | PR | Branch | Description | CI | +|------|----|--------|-------------|----| +| MobilitySpark | #8 | `doc/reviewer-guide` | **This guide** — visibility wiring (PR template + README banner) — single commit | ✅ | +| JMEOS | #8 | `SachaDelsaux:JMEOS_v1.3` | Subsumed by #9 — recommended for closure (external author; comment posted, awaiting signal) | ❓ | + +--- + +## Tier 0 — Performance (cross-platform th3index unification) + +Cross-platform unification: all three benchmarked platforms (MobilityDB, MobilityDuck, MobilitySpark) execute identical portable SQL with the th3index spatial prefilter. PostgreSQL/MobilityDB additionally gets GiST + SP-GiST indexes — the native machinery that the columnar prefilter simulates on the other two platforms. **Land MobilityDB #807 / #866 / #893 / #938 first (foundation + polygon-side public API); then MobilityDB-BerlinMOD #24 (data side); then this PR #9 (consumer side).** + +| Repo | PR | Branch | Description | CI | Notes | +|------|----|--------|-------------|----|-------| +| MobilityDB | **#938** | `estebanzimanyi:feat/h3-static-geo-coverage` | Static-geometry → H3 cell set public API: `h3_gs_point_to_cell` (promoted to public) + `geo_to_h3index_set` (POINT/LINESTRING/POLYGON/MULTI*/GeometryCollection in one walker) + `ever_eq_anyof_h3indexset_th3index`. PG SQL wrappers. pg_regress fixtures verified locally on PG 17 build (15/19 pass; 2 intentional ERROR; 2 wait on a pre-existing th3index branch SRID-resolver gap). | ❓ | Stacks on MobilityDB #866. Unblocks the polygon-side BerlinMOD prefilter consumed by this PR's q02.sql. | +| MobilityDB-BerlinMOD | **#24** | `estebanzimanyi:feat/portability-export-th3index` | Extend `berlinmod_portability_export()` to write a 4-column `trips.csv` including `trip_h3` (th3index hex-WKB at H3 resolution 7). Single SQL function change. | ❓ | Data-side, depends on `tgeompoint_to_th3index` from MobilityDB #807 / #866. | +| MobilitySpark | **#9** | `estebanzimanyi:perf/spark-mt-and-binary` | Cross-platform th3index unification: 86 UDFs (Th3IndexUDFs at 100% parity to `meos_h3.h`); load-time `trip_h3` materialisation; portable BerlinMOD SQL (q02/q04/q05/q06/q10) adopts the prefilter directly — including the polygon-side Q2 path via MobilityDB #938's `geoToH3IndexSet` + `everIntersectsH3IndexSet_Th3Index`; load_mbdb.sql adds GiST + SP-GiST indexes; load_mduck.sql + setup/generate_data.sh updated. `preprocessForSpark`'s th3index injection rules removed (now redundant with portable SQL). | ❌ | Source-complete; CI builds will fail until MobilityDB #807 / #866 / #893 / #938 land + JMEOS regen exposes the new symbols (parallel-session `feat/regen-against-meos-1.4`) + MobilityDuck th3index port lands. | + +--- + +## Tier 2 — Cross-repo chain (stack in order: JMEOS → MobilitySpark) + +| Repo | PR | Branch | Description | CI | Notes | +|------|----|--------|-------------|----|-------| +| JMEOS | #9 | `JashanReel:fix-tests-using-docker` | Multi-module Maven layout (`jmeos-core/`); MEOS 1.3 API; test fixes | ❓ | **Land first** — needs cleanup (IDE files, binary blobs, *.class, squash 78 commits) | +| JMEOS | #12 | `estebanzimanyi:fix/multimodule-with-split-interface` | Split `MeosLibrary` 1685-method interface into 4 `public static` sub-interfaces for JNR-FFI; removes binary blobs + `.class` + debug files; updates `.gitignore` | ❓ | Stacks on #9 | +| MobilitySpark | #7 | `estebanzimanyi:fix/license-main-java` | Multi-platform CI bootstrap: license check, compile, 51 unit tests on Linux; macOS/Windows non-blocking | ✅⚠️ | Stacks on JMEOS #12 | +| MobilitySpark | #5 | `estebanzimanyi:feat/jmeos-1.3-berlinmod-poc` | JMEOS 1.3 + BerlinMOD Q1–Q17 + TemporalParquet edge-to-cloud pipeline; 37/37 tests | ✅ | Stacks on #7 | + +--- + +## Tier 3 — Fork staging (awaiting upstream merge) + +These PRs exist on the fork and are awaiting upstream review after the Tier 2 chain merges. + +| Repo | PR | Branch | Description | CI | Notes | +|------|----|--------|-------------|----|-------| +| MobilitySpark fork (`estebanzimanyi/MobilitySpark`) | #1 | `feat/udf-parity-phase2` | Expand UDF surface: 141 new UDFs in 7 classes + JMEOS-1.4 sub-interface fix; 203/203 tests | ✅ | Depends on JMEOS #11 being merged upstream | + +### UDF breakdown for fork PR #1 + +| Class | UDFs | Summary | +|-------|------|---------| +| `ConstructorUDFs` | 18 | Text-literal constructors for temporal/span/set/box types | +| `AccessorUDFs` | 25 | start/end/min/max value, shift, scale, atSpan, atSpanset | +| `SpanAlgebraUDFs` | 23 | Span+set topology predicates + algebraic operations | +| `AnalyticsUDFs` | 12 | tfloat math, tnumber integral/twavg, tpoint length/speed/azimuth/direction | +| `PredicateUDFs` | 36 | Temporal order comparisons + ever/always lifting | +| `OutputUDFs` | 15 | Text serialisation, metadata, instant/sequence navigation | +| `TemporalLiftingUDFs` | 30 | Lifted comparisons (tbool), arithmetic, deltaValue, tprecision, tsample | + +Total: 40 pre-existing + 141 new = **181 UDFs**. + +--- + +## Review checklist + +For every MobilitySpark / JMEOS PR, verify: + +- [ ] PostgreSQL License header on every `.java` file +- [ ] `meos_initialize()` in `@BeforeAll`; **no** `meos_finalize()` in `@AfterAll` +- [ ] Surefire `forkCount=1 reuseForks=false` preserved in `pom.xml` +- [ ] New UDF: `null` input → `null` output (STRICT semantics) +- [ ] New UDF: `DBL_MAX` MEOS return → `null` Java return (NAD sentinel) +- [ ] No large binary data files (> 10 MB) in the commit +- [ ] CI green on Linux before requesting merge 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/doc/spark-version.md b/doc/spark-version.md new file mode 100644 index 00000000..aea20679 --- /dev/null +++ b/doc/spark-version.md @@ -0,0 +1,68 @@ +# Spark version target + +MobilitySpark targets **Apache Spark 3.5.x** (the current LTS line). One artefact, one supported Spark major. + +## Position table + +| Axis | Choice | Why | +|---|---|---| +| Spark engine version | **3.5.x** only | LTS line through 2026; the production-line default in every managed Spark distribution (Databricks DBR 15, AWS EMR 7.0-7.4, Google Dataproc image 2.2, Azure Synapse pool default). One MobilitySpark jar runs on the whole 3.x line because the Java/Scala API surface of `spark-core` is stable across 3.0 → 3.5. | +| MEOS C-library version | follows JMEOS | The two existing MEOS lines (v1.3 on MobilityDB master, v1.4 as the in-flight 15-PR bump) flow through JMEOS as separate jar builds. MobilitySpark pins one JMEOS jar; JMEOS pins one MEOS SHA. Version discipline lives in JMEOS, not here. | +| Scala version | 2.12 / 2.13 (as Spark 3.5 supports) | The Maven profile selects against `spark-core_2.13` by default; `_2.12` is available for adopters on the older Scala line. | + +## Why not Spark 4.0 today + +Spark 4.0 (May 2025 GA) is **early-adoption**, not production-default. Concrete signals: + +| Distribution / ecosystem | Default Spark version | Spark 4 status | +|---|---|---| +| Databricks Runtime | DBR 15 = Spark 3.5 | DBR 16 (Spark 4) available, not the UI default | +| AWS EMR | EMR 7.0-7.4 = Spark 3.5 | EMR 7.5+ has Spark 4, not the default image | +| Google Dataproc | Image 2.2 = Spark 3.5 LTS | Image 2.3 (Spark 4) in preview | +| Azure Synapse / HDInsight | Spark 3.5 pool | Spark 4 not yet GA in the managed runtime | +| Cloudera CDP | Spark 3.5 | Spark 4 not yet shipped | +| Delta Lake | Delta 3.x → Spark 3.4 / 3.5 | Delta 4.0 → Spark 4 (separate release line) | +| Apache Iceberg | `iceberg-spark-runtime-3.5` stable | `iceberg-spark-runtime-4.0` in Iceberg 1.7+, recently-stabilised | +| Apache Hudi | Spark 3.x supported across recent releases | Spark 4 support rolling out in the 1.x line | +| Apache Sedona (spatial, closest analogue) | Spark 3.4 / 3.5 first-class | Spark 4 added in Sedona 1.7 (late 2025), some modules still flagged experimental | + +Spark 4 also introduces behavioural breakers (ANSI-by-default, type widening, parameterised SQL) that **break existing 3.x SQL**, so enterprise data teams typically wait 12-18 months before migrating because every SQL workload needs revalidation. + +## Trigger signals that switch this position + +Commit to Spark 4 support when **two or more** of these fire: + +| Signal | Why it matters | +|---|---| +| Databricks DBR 16 becomes the default runtime in the Databricks UI | Mainstream tipping point — production workloads start moving | +| AWS EMR 7.5+ becomes the default in the EMR console | Same, for AWS | +| Iceberg makes Spark 4 the **recommended** runtime (not just supported) | Data-lake stack consensus | +| Apache Sedona drops the "experimental" qualifier on Spark 4 modules | Direct spatial-analogue signal | +| A MobilityDB user opens a Spark-4 issue against MobilitySpark | Concrete demand | + +None have fired as of this writing. Track them. + +## What the version axis looks like if/when Spark 4 is added + +The pattern would mirror MobilityDuck's multi-DuckDB-version foundation (`MobilityDuck/doc/multi-duckdb-version.md`): + +- Maven profile per Spark version (`mvn -Pspark-3.5` / `mvn -Pspark-4.0`); each profile pins the matching `spark-core` dependency. +- `if (sparkVersionAtLeast("4.0.0")) { … } else { … }` preprocessor-style branches for the small set of API divergences (`udf.register` shape, `DataType.fromName`, deprecated `ScalaUDF` constructors). +- CI matrix dimension `spark_version: [3.5.4, 4.0.0]`; each row builds a separate jar. +- Per-Spark-version jar in the release artefacts (`mobilityspark-1.0.0-spark-3.5.jar` / `mobilityspark-1.0.0-spark-4.0.jar`). + +This is **future work**, not current. The estimated effort is small-to-medium because the Spark Java API divergences between 3.5 and 4.0 are narrow compared to the DuckDB v1.4-vs-v1.5 ABI break. + +## Relationship to MEOS-version churn + +The MEOS-version axis is **orthogonal** to the Spark-version axis. MEOS versions (v1.3, v1.4) flow through JMEOS regenerations; MobilitySpark depends on one JMEOS jar at a time. Bumping MEOS means swapping the JMEOS dependency, not touching anything Spark-version-specific. + +## Conclusion + +| Question | Answer | +|---|---| +| What Spark version does MobilitySpark target? | 3.5.x (current LTS) | +| Does MobilitySpark support Spark 4 today? | No | +| Is the lack of Spark 4 support a parity gap with the standard stack? | No — Spark 4 is early-adoption; the production stack is 3.5 | +| When will Spark 4 support be added? | When the trigger signals fire (see table above) | +| Is there a MEOS-version-axis problem MobilitySpark needs to solve? | No — JMEOS owns it; MobilitySpark pins one JMEOS jar at a time | diff --git a/docs/parity-100.md b/docs/parity-100.md new file mode 100644 index 00000000..4d0c3c16 --- /dev/null +++ b/docs/parity-100.md @@ -0,0 +1,113 @@ +# 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) | **1571/1577 active addressable covered (99.6%)** — every section 100% except the `v_clip` ABI gap below; all six families counted | [`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 (99.6%) + +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**) | **1571 / 1577 covered (99.6%)** | +| **Out of scope** (PG plumbing: `*_in/_out/_recv/_send`, `_transfn/_combinefn/_finalfn`, GiST/SPGiST/GIN index 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 `cbuffer` / `npoint` / `pose` / `rgeo` typed per-family UDF surface is +implemented (`CbufferUDFs`, `NpointUDFs`, `PoseUDFs`, `RgeoUDFs`), reusing +each function's own MEOS C symbol via the `MeosNative` raw-FFI / generic +`functions.*` pattern — no reimplementation. Every active section is at +100% with two structural exceptions: + +- **Index-plumbing exception (documented, uniform with temporal/geo).** + The GiST/GIN opclass-support callbacks of + `cbuffer/166_tcbuffer_indexes`, `npoint/092_tnpoint_gin`, + `npoint/098_tnpoint_indexes`, `pose/114_tpose_indexes`, + `rgeo/134_trgeo_indexes` are out of scope — the same PG-only index + access-method class already excluded for `temporal/043_temporal_gist`, + `geo/073_tgeo_gist`, etc. Index methods are PG-internal; Spark has no + equivalent. + +- **`rgeo/133_trgeo_vclip` — MEOS-library ABI gap (6 functions).** + The `v_clip_*` user surface is implemented only in the `mobilitydb` + PostgreSQL extension (`VClip_*` `MODULE_PATHNAME` wrappers), not in the + MEOS C library MobilitySpark links. `lib/libmeos.so` exports only the + low-level kernels `v_clip_tpoly_point` / `v_clip_tpoly_tpoly`, which + take raw PostGIS `LWPOLY*`/`LWPOINT*`/`Pose*` structs plus + out-parameters — there is no `GSERIALIZED`/`Temporal` entry point + reachable from the hex-WKB string convention — and the other four + (`v_clip_poly_point`, `v_clip_poly_poly`, `v_clip_tpoly_poly`, + `v_clip_tpoly_tpoint`) are not exported at all. These six are recorded + as a documented gap and intentionally **not stubbed**: binding them + requires an `extern "C"` GSERIALIZED/Temporal-level v-clip entry point + to be added to MEOS upstream (proposed fix: export + `v_clip_trgeo_geo` / `v_clip_trgeo_trgeo` wrappers that accept + `GSERIALIZED`/`Temporal` and a `TimestampTz`, returning the scalar + clip distance — mirroring the existing `tdistance_trgeo_*` exports). + +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..74615bc1 --- /dev/null +++ b/docs/parity-status.md @@ -0,0 +1,193 @@ +# MobilitySpark parity status — surface-level audit + +Generated 2026-05-18. **Active addressable scope** (temporal + geo, excluding PG-only helpers): 1571/1577 names covered (99.6%). + +**Out of scope** (PG-only — no Spark equivalent exists): 601 names skipped — 91 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 | 18 | 0 | 100% | 13 | 7 | +| `cbuffer/151_cbufferset.in.sql` | 27 | 27 | 0 | 100% | 15 | 23 | +| `cbuffer/152_tcbuffer.in.sql` | 71 | 71 | 0 | 100% | 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/167_portable_aliases.in.sql` | 19 | 19 | 0 | 100% | 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 | +| `geo/079_portable_aliases.in.sql` | 23 | 23 | 0 | 100% | 0 | 0 | +| `npoint/081_npoint.in.sql` | 19 | 19 | 0 | 100% | 22 | 12 | +| `npoint/082_npointset.in.sql` | 28 | 28 | 0 | 100% | 15 | 23 | +| `npoint/083_tnpoint.in.sql` | 65 | 65 | 0 | 100% | 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 | 4 | 0 | 100% | 0 | 20 | +| `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/099_portable_aliases.in.sql` | 19 | 19 | 0 | 100% | 0 | 0 | +| `pose/100_pose.in.sql` | 21 | 21 | 0 | 100% | 13 | 7 | +| `pose/101_poseset.in.sql` | 31 | 31 | 0 | 100% | 15 | 23 | +| `pose/102_tpose.in.sql` | 72 | 72 | 0 | 100% | 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/115_portable_aliases.in.sql` | 23 | 23 | 0 | 100% | 0 | 0 | +| `rgeo/122_trgeo.in.sql` | 74 | 74 | 0 | 100% | 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/135_portable_aliases.in.sql` | 19 | 19 | 0 | 100% | 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 | +| `temporal/048_portable_aliases.in.sql` | 19 | 19 | 0 | 100% | 0 | 0 | +| **TOTAL (active)** | **1577** | **1571** | **6** | **100%** | **510** | — | + +## Missing function names per active section + +### `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` + +## 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, PG geometric type constructors (`019_geo_constructors`), and the sibling-family GiST/GIN index opclass-support callbacks (`cbuffer/166_tcbuffer_indexes`, `npoint/092_tnpoint_gin`, `npoint/098_tnpoint_indexes`, `pose/114_tpose_indexes`, `rgeo/134_trgeo_indexes` — the same index-plumbing class already excluded for temporal/geo). None of them have Spark equivalents and they should not be implemented; listed here only for completeness. + +### Whole sections excluded + +| Section | Names | +|---|---:| +| `cbuffer/166_tcbuffer_indexes.in.sql` | 1 | +| `geo/073_tgeo_gist.in.sql` | 8 | +| `geo/073_tpoint_gist.in.sql` | 3 | +| `geo/074_tgeo_spgist.in.sql` | 9 | +| `npoint/092_tnpoint_gin.in.sql` | 3 | +| `npoint/098_tnpoint_indexes.in.sql` | 1 | +| `pose/114_tpose_indexes.in.sql` | 1 | +| `rgeo/134_trgeo_indexes.in.sql` | 1 | +| `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/libs/JMEOS.jar b/libs/JMEOS.jar new file mode 100644 index 00000000..f10b9d4a Binary files /dev/null and b/libs/JMEOS.jar differ diff --git a/pom.xml b/pom.xml index 417d4287..b6097f82 100644 --- a/pom.xml +++ b/pom.xml @@ -9,8 +9,8 @@ 1.0-SNAPSHOT - 17 - 17 + 21 + 21 UTF-8 @@ -18,12 +18,12 @@ org.apache.spark spark-core_2.13 - 3.4.0 + 3.5.1 org.apache.spark spark-sql_2.13 - 3.4.0 + 3.5.1 compile @@ -35,7 +35,120 @@ com.github.jnr jnr-ffi - 2.2.11 + 2.2.17 + + + org.junit.jupiter + junit-jupiter + 5.10.0 + test + + + + + + org.codehaus.mojo + exec-maven-plugin + 3.1.0 + + + generate-udfs + generate-sources + exec + + python3 + + ${project.basedir}/tools/codegen_spark_udfs.py + --catalog + ${project.basedir}/tools/meos-idl.json + --jar + ${settings.localRepository}/org/jmeos/meos/1.0/meos-1.0.jar + --out + ${project.build.directory}/generated-sources/spark/org/mobilitydb/spark/generated + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.5.0 + + + add-generated-source + generate-sources + add-source + + + ${project.build.directory}/generated-sources/spark + + + + + + + + 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 + + + --add-opens=java.base/java.lang=ALL-UNNAMED + --add-opens=java.base/java.lang.invoke=ALL-UNNAMED + --add-opens=java.base/java.lang.reflect=ALL-UNNAMED + --add-opens=java.base/java.io=ALL-UNNAMED + --add-opens=java.base/java.net=ALL-UNNAMED + --add-opens=java.base/java.nio=ALL-UNNAMED + --add-opens=java.base/java.util=ALL-UNNAMED + --add-opens=java.base/java.util.concurrent=ALL-UNNAMED + --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED + --add-opens=java.base/java.util.concurrent.locks=ALL-UNNAMED + --add-opens=java.base/java.util.zip=ALL-UNNAMED + --add-opens=java.base/sun.nio.ch=ALL-UNNAMED + --add-opens=java.base/sun.nio.cs=ALL-UNNAMED + --add-opens=java.base/sun.security.action=ALL-UNNAMED + --add-opens=java.base/sun.util.calendar=ALL-UNNAMED + + + + + \ No newline at end of file diff --git a/setup/generate_data.sh b/setup/generate_data.sh new file mode 100755 index 00000000..ecb49c9f --- /dev/null +++ b/setup/generate_data.sh @@ -0,0 +1,161 @@ +#!/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" +# The canonical generator (MobilityDB-BerlinMOD berlinmod_portability_export) +# writes every CSV directly — vehicles, trips (hex-EWKB), licences, instants, +# points, periods, regions — as RAW lat/lon in SRID 4326 (the canonical default). +# load.sql then builds the H3 prefilter columns (th3index / geoToH3IndexSet), which +# require EPSG:4326; nearestApproachDistance on the 4326 geodetic trips returns true +# metres. No per-tool post-processing, reprojection, or committed corpus copy. +_psql -c "SELECT berlinmod_portability_export('${OUTPUT}/', 7, 4326);" + +# ── 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..ef62f8c5 --- /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 = GeneratedFunctions.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/MeosThread.java b/src/main/java/org/mobilitydb/spark/MeosThread.java new file mode 100644 index 00000000..17c689f0 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MeosThread.java @@ -0,0 +1,73 @@ +/***************************************************************************** + * + * 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.GeneratedFunctions; +import functions.error_handler_fn; + +/** + * Per-thread MEOS initialisation for Spark executor threads. + * + * In Spark's multi-threaded executor model every task thread initialises + * MEOS independently. meos_initialize() sets up the per-thread MEOS state + * (session_timezone, timezone cache, GEOS context, PROJ context, GSL RNGs, + * errno). The ThreadLocal in MEOS_READY runs initialisation exactly once + * per native thread. + * + * The entire UDF surface is generated (GeneratedSpatioTemporalUDFs); every + * generated entry point calls {@link #ensureReady()} before its first MEOS + * call, so the executor thread running it is always initialised. There are no + * hand-registered UDFs, so this class exposes only the guard — no registration + * helpers. + */ +public final class MeosThread { + + private MeosThread() {} + + /** + * No-exit MEOS error handler. MEOS's default handler calls + * exit(EXIT_FAILURE) on an ERROR, which would tear down the whole JVM if a + * MEOS error fired inside a Spark task. This handler returns instead of + * exiting; the error still surfaces because MEOS sets meos_errno, which the + * generated wrappers check (MeosErrorHandler.checkError) and rethrow as a + * Java exception. Held as a static field so JNR keeps the native callback + * alive for the process lifetime. + */ + public static final error_handler_fn NOEXIT_ERROR_HANDLER = + (errorLevel, errorCode, errorMessage) -> { /* do not exit the JVM */ }; + + private static final ThreadLocal MEOS_READY = ThreadLocal.withInitial(() -> { + GeneratedFunctions.meos_initialize(); + GeneratedFunctions.meos_initialize_timezone("UTC"); + GeneratedFunctions.meos_initialize_error_handler(NOEXIT_ERROR_HANDLER); + return Boolean.TRUE; + }); + + /** Ensure MEOS is initialised for the calling thread. */ + public static void ensureReady() { + MEOS_READY.get(); + } +} 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..7d3d99ba --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/MobilitySparkSession.java @@ -0,0 +1,99 @@ +/***************************************************************************** + * + * 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.generated.GeneratedSpatioTemporalUDFs; + +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.GeneratedFunctions.meos_set_spatial_ref_sys_csv; + +/** + * Entry point for MobilitySpark. + * + *

Initialises MEOS and registers the entire catalog-GENERATED UDF surface + * with the given SparkSession. The UDFs are produced at build time by + * {@code tools/codegen_spark_udfs.py} from the MEOS-API catalog (North Star: + * bindings are generated from MEOS, never hand-written), so this session holds + * no hand-registered operator logic — it wires MEOS init + the generated + * {@link GeneratedSpatioTemporalUDFs#registerAll(SparkSession)}. + * + * 

{@code
+ *   SparkSession spark = SparkSession.builder().master("local[2]").getOrCreate();
+ *   try (MobilitySparkSession ms = MobilitySparkSession.create(spark)) {
+ *       spark.sql("SELECT numInstants(trip) 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) { + // MeosThread.ensureReady() performs the guarded, idempotent MEOS init + // (meos_initialize + UTC timezone + the no-exit error handler) that every + // generated UDF also calls per worker thread. + MeosThread.ensureReady(); + registerSpatialRefSys(); + GeneratedSpatioTemporalUDFs.registerAll(spark); + return new MobilitySparkSession(); + } + + /** + * Extracts the bundled spatial_ref_sys.csv to a temp file and registers it with + * MEOS so geodetic coordinate operations can look up SRID definitions without a + * PostGIS installation. Only runs once per JVM, and is a no-op when the resource + * is absent (the planar BerlinMOD benchmark does not need it). + */ + 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 global state is process-wide; leave it initialised for the JVM + // lifetime (meos_finalize is not called so a second create() is safe). + } +} 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..39b26ac4 --- /dev/null +++ b/src/main/java/org/mobilitydb/spark/demo/BerlinMODBench.java @@ -0,0 +1,407 @@ +/***************************************************************************** + * + * 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 come from the canonical {@code berlinmod-portability} + * suite, vendored as the {@code berlinmod/suite/} git submodule (the single + * source shared by MobilityDB, MobilityDuck, and MobilitySpark). Override + * the location with the system property {@code berlinmod.sql.dir}; the + * runner {@code bench/bench_mspark.sh} sets it to {@code berlinmod/suite}. + * When unset it falls back to the parent of the data directory. + */ +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)) { + // MobilitySparkSession.create registers the full catalog-generated surface + // (length, valueAtTimestamp, expandSpace, ... are @sqlfn names on it). + + // Load and cache all tables — loading time is NOT in the query timings + System.out.println("=== Loading data from: " + dataDir + " ==="); + loadFromCsv(spark, dataDir, sqlDir); + + // trip_h3 / geom_h3 (the H3 cell-set prefilter for the Trips×Trips queries) + // are built by the canonical load.sql above via th3index / geoToH3IndexSet — + // the same shared source every engine runs, so the prefilter is identical. + + 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. + // Every engine runs the identical canonical .sql, EXCEPT the few + // whose canonical form uses PG-only SQL that Spark cannot express — an + // ordered aggregate `array_agg(x ORDER BY k)` and the SETOF table-function + // form `f(...) AS p(i, j)` (the NxN q06/q10). For those, a documented + // Spark-dialect override in berlinmod/spark-dialect/.sql (same MEOS UDFs, + // same result; collect_list + array_sort + transform, LATERAL VIEW explode) + // is used when present. The MEOS computation is identical — only the SQL + // glue differs, because the engines genuinely diverge on these constructs. + Path dialectDir = Paths.get(sqlDir).getParent() == null ? null + : Paths.get(sqlDir).getParent().resolve("spark-dialect"); + for (String q : queryList) { + Path canonical = Paths.get(sqlDir, q + ".sql"); + Path dialect = dialectDir == null ? null : dialectDir.resolve(q + ".sql"); + boolean useDialect = dialect != null && Files.exists(dialect); + Path sqlFile = useDialect ? dialect : canonical; + if (!Files.exists(sqlFile)) { + System.out.printf(" [skip] %s — SQL file not found%n", q); + continue; + } + String sql = 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*$", ""); + } + + /** 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(" \"tier\": 1,\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; + } + } + + /** + * Load the canonical BerlinMOD CSV corpus (produced by the single shared generator + * {@code setup/generate_data.sh} -> MobilityDB-BerlinMOD) into the {@code *Input} + * views, then build the H3 prefilter columns (trip_h3 / geom_h3) by running the + * CANONICAL {@code berlinmod/suite/load.sql} — the single shared source of the H3 + * build (th3index(trip,7) / geoToH3IndexSet(geom,7)), with NO Spark-local H3 logic. + * + *

The only engine adaptation is the DDL form (Spark {@code CREATE OR REPLACE TEMP + * VIEW} for PG {@code CREATE TABLE AS}); the H3 SELECT is untouched. trip is the + * hex-WKB String the UDFs parse via temporal_from_hexwkb; instant/period are kept as + * RAW Strings (exact +HH zone preserved) and parsed by the atTime UDF through MEOS + * (pg_timestamptz_in / tstzspan_in). geom is WKT parsed via geo_from_text. + * + *

Requires the catalog to expose {@code th3index} / {@code geoToH3IndexSet} (the + * MEOS-C {@code @csqlfn} tags on tgeompoint_to_th3index / geo_to_h3index_set) and the + * data to be EPSG:4326 (H3 raises on a non-latlong SRID). + */ + static void loadFromCsv(SparkSession spark, String dataDir, String sqlDir) { + String dir = dataDir.endsWith("/") ? dataDir : dataDir + "/"; + // integer-keyed inputs: inferSchema (trip hex / geom WKT stay String). + String[][] inferred = { + {"vehicles.csv", "Vehicles"}, {"query_licences.csv", "QueryLicences"}, + {"trips.csv", "TripsInput"}, {"query_points.csv", "QueryPointsInput"}, + {"query_regions.csv", "QueryRegionsInput"}, + }; + for (String[] io : inferred) + spark.read().option("header", "true").option("inferSchema", "true") + .csv(dir + io[0]).createOrReplaceTempView(io[1]); + // instant / period: keep the RAW text exactly (no inferSchema — preserve the +HH + // zone the atTime UDF parses via MEOS), only the id is cast. + 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, instant FROM QueryInstantsRaw"); + 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"); + // Build the H3 columns via the canonical load.sql (single source). + try { + for (String stmt : stripComments(Files.readString(Paths.get(sqlDir, "load.sql"))).split(";")) { + String s = stmt.replaceAll("(?i)CREATE\\s+TABLE", "CREATE OR REPLACE TEMP VIEW").trim(); + if (!s.isEmpty()) spark.sql(s); + } + } catch (java.io.IOException e) { + throw new RuntimeException("could not read canonical load.sql at " + sqlDir, e); + } + } +} 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/GeneratedSurfaceTest.java b/src/test/java/org/mobilitydb/spark/GeneratedSurfaceTest.java new file mode 100644 index 00000000..228ee581 --- /dev/null +++ b/src/test/java/org/mobilitydb/spark/GeneratedSurfaceTest.java @@ -0,0 +1,269 @@ +package org.mobilitydb.spark; + +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.SparkSession; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.mobilitydb.spark.generated.GeneratedSpatioTemporalUDFs; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Runtime verification that the catalog-GENERATED UDF surface actually binds and + * executes against libmeos through JMEOS — the safety gate before the hand-written + * UDF layers (PRs #22/#24/#25/#26) are retired. Exercises a representative set of + * generated 1:1 UDFs (scalar results + I/O) across families, driven by a known + * tint hex-WKB ([1@2001-01-01, 2@2001-01-02, 1@2001-01-03]). + */ +class GeneratedSurfaceTest { + + // [1@2001-01-01, 2@2001-01-02, 1@2001-01-03] as MEOS hex-WKB (variant 0). + private static final String TINT_HEX = + "0123000A030000000301000000009C57D3C11C00000200000000FC2EF1D51C000001000000005C060FEA1C0000"; + + private static SparkSession spark; + private static Map byOperator; + + @BeforeAll + static void setup() throws Exception { + spark = SparkSession.builder().appName("gen-verify").master("local[1]") + .config("spark.ui.enabled", "false").getOrCreate(); + GeneratedSpatioTemporalUDFs.registerAll(spark); + // The operator->bare-name dialect, read from the SAME catalog the generator emits + // from, so a dialect rename (e.g. ?= ever_eq->eEq, <-> tdistance->tDistance) updates + // this test automatically instead of hard-coding the names. byOperator is a flat + // string->string map; parse it directly (Spark's bundled jackson is version-skewed). + byOperator = new HashMap<>(); + String json = Files.readString(Paths.get("tools/meos-idl.json")); + int b = json.indexOf('{', json.indexOf("\"byOperator\"")); + Matcher m = Pattern.compile("\"([^\"]+)\"\\s*:\\s*\"([^\"]+)\"") + .matcher(json.substring(b + 1, json.indexOf('}', b))); + while (m.find()) byOperator.put(m.group(1), m.group(2)); + } + + @AfterAll + static void teardown() { if (spark != null) spark.stop(); } + + /** Canonical bare name for a SQL operator, per the catalog's byOperator map. */ + private static String op(String operator) { + String n = byOperator.get(operator); + assertNotNull(n, "catalog byOperator has no entry for " + operator); + return n; + } + + private Object scalar(String sql) { + Row r = spark.sql(sql).collectAsList().get(0); + return r.isNullAt(0) ? null : r.get(0); + } + + @Test + void generatedSurface_registers_and_runs() { + // scalar accessor: 3 instants + assertEquals(3, ((Number) scalar( + "SELECT temporal_num_instants('" + TINT_HEX + "')")).intValue()); + // scalar accessor: start value = 1 + assertEquals(1, ((Number) scalar( + "SELECT tint_start_value('" + TINT_HEX + "')")).intValue()); + // I/O round-trip: tint_out is non-null and renders the int values 1,2,1 + // (timestamps are rendered in UTC, so don't assert on the wall-clock date). + Object out = scalar("SELECT tint_out('" + TINT_HEX + "')"); + assertNotNull(out); + String s = out.toString(); + assertTrue(s.startsWith("[1@") && s.contains("2@"), + "tint_out should render the values, got: " + s); + } + + @Test + void numeric_op_on_generated_surface() { + // tnumber_integral over the linear-free (step) tint is a finite double + Object integral = scalar("SELECT tnumber_integral('" + TINT_HEX + "')"); + assertNotNull(integral); + assertTrue(((Number) integral).doubleValue() >= 0.0); + } + + // [1.5@2001-01-01, 2.5@2001-01-02] (linear tfloat) + private static final String TFLOAT_HEX = + "0121000E0200000003000000000000F83F009C57D3C11C0000000000000000044000FC2EF1D51C0000"; + // [Point(1 1)@2001-01-01, Point(2 2)@2001-01-02] (tgeompoint) + private static final String TGEOMPOINT_HEX = + "012E000E02000000030101000000000000000000F03F000000000000F03F009C57D3C11C0000010100000000" + + "00000000000040000000000000004000FC2EF1D51C0000"; + + @Test + void breadth_across_families_and_marshalling_kinds() { + // Double marshalling: start value of the tfloat = 1.5 + assertEquals(1.5, ((Number) scalar( + "SELECT tfloat_start_value('" + TFLOAT_HEX + "')")).doubleValue(), 1e-9); + // Double op: time-weighted average of a linear [1.5 -> 2.5] segment = 2.0 + assertEquals(2.0, ((Number) scalar( + "SELECT tnumber_twavg('" + TFLOAT_HEX + "')")).doubleValue(), 1e-9); + // Boolean marshalling: tfloat ever equals 1.5 (true) but never 5.0 (false). + // Cast the literal: Spark SQL parses 1.5 as decimal; the UDF takes a double. + assertEquals(Boolean.TRUE, scalar( + "SELECT ever_eq_tfloat_float('" + TFLOAT_HEX + "', CAST(1.5 AS DOUBLE))")); + assertEquals(Boolean.FALSE, scalar( + "SELECT ever_eq_tfloat_float('" + TFLOAT_HEX + "', CAST(5.0 AS DOUBLE))")); + // geo temporal: a tgeompoint has 2 timestamps (exercises the geo family + hex) + assertEquals(2, ((Number) scalar( + "SELECT temporal_num_timestamps('" + TGEOMPOINT_HEX + "')")).intValue()); + } + + // [Cbuffer(Point(1 1),0.5)@2001-01-01, Cbuffer(Point(2 2),1.5)@2001-01-02] + private static final String TCBUFFER_HEX = + "013B000E0200000003000000000000F03F000000000000F03F000000000000E03F009C57D3C11C0000" + + "00000000000000400000000000000040000000000000F83F00FC2EF1D51C0000"; + // [Npoint(1,0.2)@2001-01-01, Npoint(1,0.8)@2001-01-02] + private static final String TNPOINT_HEX = + "0133000E02000000030101000000000000009A9999999999C93F009C57D3C11C0000010100000000000000" + + "9A9999999999E93F00FC2EF1D51C0000"; + + @Test + void extended_families_cbuffer_and_npoint() { + // tcbuffer (2 instants) + a cbuffer-family op (radius -> a tfloat, non-null) + assertEquals(2, ((Number) scalar( + "SELECT temporal_num_instants('" + TCBUFFER_HEX + "')")).intValue()); + assertNotNull(scalar("SELECT tcbuffer_radius('" + TCBUFFER_HEX + "')")); + // tnpoint (2 instants) — exercises the network-point family marshalling + assertEquals(2, ((Number) scalar( + "SELECT temporal_num_instants('" + TNPOINT_HEX + "')")).intValue()); + } + + @Test + void portable_bare_name_dispatch_surface() { + // The portable bare-name operator dialect, emitted by the generator's DISPATCH pass + // — NOT hand-registered. The bare names are read from the catalog's byOperator map + // (op(...)) rather than hard-coded, so the dialect (e.g. ?=->eEq, <->->tDistance) is + // the single source: a rename updates this test automatically. One assertion per + // family proves the superclass entrypoint dispatches the concrete subtype from hex-WKB. + // topology (&&): two identical tints overlap in time → true + assertEquals(Boolean.TRUE, scalar( + "SELECT " + op("&&") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // same (~=): a value equals itself + assertEquals(Boolean.TRUE, scalar( + "SELECT " + op("~=") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // time position (&<#): a value's period overbefore-overlaps itself → true + assertEquals(Boolean.TRUE, scalar( + "SELECT " + op("&<#") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // temporal comparison (#=): of a value with itself is a temporal bool, non-null + assertNotNull(scalar("SELECT " + op("#=") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // ever comparison (?=): same value → true + assertEquals(Boolean.TRUE, scalar( + "SELECT " + op("?=") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // space-X axis classifier (&<): a value is overleft-of itself on its value axis → + // true (exercises axisBool) + assertEquals(Boolean.TRUE, scalar( + "SELECT " + op("&<") + "('" + TINT_HEX + "', '" + TINT_HEX + "')")); + // distance (<->): lifted distance between two coincident tgeompoints → a temporal + // (hex-WKB) of all-zero distance, non-null + assertNotNull(scalar( + "SELECT " + op("<->") + "('" + TGEOMPOINT_HEX + "', '" + TGEOMPOINT_HEX + "')")); + } + + @Test + void sqlfn_canonical_names_with_argkind_dispatch() { + // The @sqlfn pass emits the canonical MobilityDB SQL names. Several map to + // multiple C overloads dispatched by arg KIND at runtime — verify the dispatch + // routes correctly on the tgeompoint trip ([Point(1 1)@.., Point(2 2)@..]). + // eIntersects(tgeo, tgeo): trip ever-intersects itself -> true. int(1/0/-1) C + // return is marshalled to Boolean by the predicate convention. + assertEquals(Boolean.TRUE, scalar( + "SELECT eIntersects('" + TGEOMPOINT_HEX + "', '" + TGEOMPOINT_HEX + "')")); + // eDwithin(tgeo, tgeo, dist): 3-arg overload (P,P,Double), within 10 of itself -> true + assertEquals(Boolean.TRUE, scalar( + "SELECT eDwithin('" + TGEOMPOINT_HEX + "', '" + TGEOMPOINT_HEX + "', CAST(10.0 AS DOUBLE))")); + // isHex guard + arg-kind dispatch on a MIXED (tgeo, geo-WKT) call: the WKT literal + // must NOT crash the hex parser (isHex(false) -> skip the tgeo_tgeo candidate), + // and the (tgeo, geo) overload then runs and returns a valid boolean (not null, + // not a segfault). The exact truth value depends on the trip interpolation. + assertNotNull(scalar( + "SELECT eIntersects('" + TGEOMPOINT_HEX + "', 'LINESTRING(1.5 0, 1.5 5)')")); + // nearestApproachDistance(tgeo, tgeo): coincident -> 0.0 (tgeo_tgeo, NOT tgeo_geo) + assertEquals(0.0, ((Number) scalar( + "SELECT nearestApproachDistance('" + TGEOMPOINT_HEX + "', '" + TGEOMPOINT_HEX + "')")).doubleValue(), 1e-9); + // (atTime over a text period is a span text-vs-hex input concern handled in the + // bench-rebuild phase; the arg-kind dispatch mechanism is proven above.) + // atTime time-restrict polymorphism via a runtime-classified String arg: a + // period "[..]" routes to temporal_at_tstzspan, a bare timestamp to + // temporal_at_timestamptz (Spark can't overload, so both go through one UDF). + assertEquals(2, ((Number) scalar("SELECT numInstants(atTime('" + TGEOMPOINT_HEX + + "', '[2001-01-01, 2001-01-03]'))")).intValue()); + assertEquals(1, ((Number) scalar("SELECT numInstants(atTime('" + TGEOMPOINT_HEX + + "', '2001-01-01 00:00:00+00'))")).intValue()); + // trajectory: SQL-faithful 1-arg (the C tpoint_trajectory(Temporal, bool) flag is + // SQL-optional/defaulted, consumed from sqlArity). + assertNotNull(scalar("SELECT trajectory('" + TGEOMPOINT_HEX + "')")); + // asHexWKB: SQL-faithful 1-arg (the WKB variant defaulted), round-trips. + assertEquals(3, ((Number) scalar( + "SELECT numInstants(temporal_from_hexwkb(asHexWKB('" + TINT_HEX + "')))")).intValue()); + // numInstants: a single-overload @sqlfn accessor under its canonical SQL name + assertEquals(3, ((Number) scalar( + "SELECT numInstants('" + TINT_HEX + "')")).intValue()); + } + + @Test + void as_hexwkb_family_with_swallowed_size_out_param() { + // temporal_as_hexwkb returns char* with a trailing size_t* size_out out-param + // that JMEOS swallows, plus an `unsigned char variant` -> ByteType. Generated + // now that the size_out is dropped and unsigned char maps to byte. Round-trips: + // parse the hex, re-serialize (variant 4 = canonical hex), re-parse -> 3 instants. + Object hex = scalar( + "SELECT temporal_as_hexwkb(tint_in('[1@2001-01-01, 2@2001-01-02, 1@2001-01-03]'), CAST(4 AS BYTE))"); + assertNotNull(hex); + assertEquals(3, ((Number) scalar( + "SELECT temporal_num_instants(temporal_from_hexwkb('" + hex + "'))")).intValue()); + } + + @Test + void parser_round_trip_entirely_on_the_generated_surface() { + // tint_in is the newly-generated cstring (WKT) parser: a full parse->operate + // round-trip driven only by generated UDFs, no externally-computed hex. + String wkt = "[1@2001-01-01, 2@2001-01-02, 1@2001-01-03]"; + assertEquals(3, ((Number) scalar( + "SELECT temporal_num_instants(tint_in('" + wkt + "'))")).intValue()); + Object out = scalar("SELECT tint_out(tint_in('" + wkt + "'))"); + assertNotNull(out); + assertTrue(out.toString().contains("1@") && out.toString().contains("2@"), + "round-trip should render the values, got: " + out); + } + + @Test + void nxn_array_tgeoarr_udfs() { + // The generated array-in UDFs: each (Temporal**, int) C pair is a Spark array. + String p = "array('" + TGEOMPOINT_HEX + "')"; // a 1-element trip array + // minDistance(array,array) -> double: distance of a trip set to itself = 0. + assertEquals(0.0, ((Number) scalar( + "SELECT minDistance(" + p + ", " + p + ")")).doubleValue(), 1e-9); + // eDwithinPairs -> array>: the single trip is ever-within 1000 of itself, + // so exactly one [0,0] pair (indices 0-based). + assertEquals(1, ((Number) scalar( + "SELECT size(eDwithinPairs(" + p + ", " + p + ", CAST(1000.0 AS DOUBLE)))")).intValue()); + assertEquals(0, ((Number) scalar( + "SELECT eDwithinPairs(" + p + ", " + p + ", CAST(1000.0 AS DOUBLE))[0].i")).intValue()); + assertEquals(0, ((Number) scalar( + "SELECT eDwithinPairs(" + p + ", " + p + ", CAST(1000.0 AS DOUBLE))[0].j")).intValue()); + // tDwithinPairs -> array>: same pair, with a non-null period hex-WKB. + assertEquals(1, ((Number) scalar( + "SELECT size(tDwithinPairs(" + p + ", " + p + ", CAST(1000.0 AS DOUBLE)))")).intValue()); + assertNotNull(scalar( + "SELECT tDwithinPairs(" + p + ", " + p + ", CAST(1000.0 AS DOUBLE))[0].periods")); + // aDisjointPairs: a trip is never always-disjoint from itself -> no pairs. + assertEquals(0, ((Number) scalar( + "SELECT size(aDisjointPairs(" + p + ", " + p + "))")).intValue()); + // The bench's q06/q10 consumption shape: LATERAL VIEW explode over the array. + // One [0,0] pair explodes to a single row; pr.i / pr.j index back into the 0-based arrays. + assertEquals(1, ((Number) scalar( + "SELECT count(*) FROM (SELECT explode(eDwithinPairs(" + p + ", " + p + + ", CAST(1000.0 AS DOUBLE))) AS pr)")).intValue()); + // A BARE numeric literal (1000.0) is a Spark decimal, not a double — the canonical + // queries write it bare, so the dist arg must coerce via Number (not a Double cast). + assertEquals(1, ((Number) scalar( + "SELECT size(eDwithinPairs(" + p + ", " + p + ", 1000.0))")).intValue()); + } +} diff --git a/tools/codegen_spark_udfs.py b/tools/codegen_spark_udfs.py new file mode 100644 index 00000000..6ee14563 --- /dev/null +++ b/tools/codegen_spark_udfs.py @@ -0,0 +1,1204 @@ +#!/usr/bin/env python3 +"""Generate the MobilitySpark UDF surface from the MEOS-API catalog. + +North Star (meos-api-codegen-regularity): the Spark UDF surface is GENERATED +from the single MEOS-API source of truth, never hand-written. This drives the +engine over the WHOLE catalog (every @sqlfn name + every contract operator bare +name from portableAliases) — no hardcoded scope, no skip-hacks. Functions whose +types are genuinely internal (Datum/SkipList/function-pointers/out-param arrays) +are the ONLY exclusions, and they are reported, never silently skipped. + +Two emission modes: + - SINGLE: a name with one backing -> a 1:1 UDF. + - DISPATCH: a name/operator with N typed backings (Spark cannot overload by + name) -> ONE UDF that classifies each String arg by its MEOS type and routes + to the catalog-determined backing. + +Wire format (matches the portable suite): temporals travel as hex-WKB; spans, +sets, boxes, cbuffer/npoint/pose and geometries travel as TEXT; scalars are typed +Spark columns (Integer/Double/Boolean/Long/Timestamp). + +Usage: python3 tools/codegen_spark_udfs.py [--catalog PATH] [--out DIR] [--report] +""" +import argparse, json, os, sys, collections, glob, re + + +def norm(c): + return c.replace("const ", "").replace("struct ", "").strip() + + +# ── Pointer-typed args: canonical base -> (GeneratedFunctions parser, KIND) ── +# parser takes a Java String, returns a jnr Pointer (freed after the call). +PARSE = { + # Type-SAFE hex-WKB wrappers: a *_from_hexwkb parser CRASHES (SIGSEGV) on a valid-hex + # but wrong-TYPE buffer (a span hex fed to temporal_from_hexwkb). UdfMarshal.*FromHex + # reads the WKB type byte (byte1 = MeosType) and only calls the C parser when the type + # matches, else returns null — so a foreign hex is rejected, never crashes, and the + # arg-kind dispatch can safely try every candidate. + "Temporal": ("UdfMarshal.tFromHex(%s)", "K_TEMPORAL"), + "TInstant": ("UdfMarshal.tFromHex(%s)", "K_TEMPORAL"), + "TSequence": ("UdfMarshal.tFromHex(%s)", "K_TEMPORAL"), + "TSequenceSet": ("UdfMarshal.tFromHex(%s)", "K_TEMPORAL"), + "GSERIALIZED": ("UdfMarshal.geoFromText(%s)", "K_GEO"), + "Span": ("UdfMarshal.spanFromHex(%s)", "K_SPAN"), + "SpanSet": ("UdfMarshal.spansetFromHex(%s)", "K_SPANSET"), + "Set": ("UdfMarshal.setFromHex(%s)", "K_SET"), + "STBox": ("GeneratedFunctions.stbox_in(%s)", "K_STBOX"), + "TBox": ("GeneratedFunctions.tbox_in(%s)", "K_TBOX"), + "Cbuffer": ("GeneratedFunctions.cbuffer_in(%s)", "K_CBUFFER"), + "Npoint": ("GeneratedFunctions.npoint_in(%s)", "K_NPOINT"), + "Nsegment": ("GeneratedFunctions.nsegment_in(%s)", "K_NSEGMENT"), + "Pose": ("GeneratedFunctions.pose_in(%s)", "K_POSE"), + "Jsonb": ("GeneratedFunctions.jsonb_in(%s)", "K_JSONB"), +} +# ── Pointer-typed returns: canonical base -> GeneratedFunctions serializer ── +SERIAL = { + "Temporal": "GeneratedFunctions.temporal_as_hexwkb(%s, (byte) 4)", + "TInstant": "GeneratedFunctions.temporal_as_hexwkb(%s, (byte) 4)", + "TSequence": "GeneratedFunctions.temporal_as_hexwkb(%s, (byte) 4)", + "TSequenceSet": "GeneratedFunctions.temporal_as_hexwkb(%s, (byte) 4)", + "GSERIALIZED": "GeneratedFunctions.geo_as_text(%s, 15)", + "Span": "GeneratedFunctions.span_as_hexwkb(%s, (byte) 4)", + "SpanSet": "GeneratedFunctions.spanset_as_hexwkb(%s, (byte) 4)", + "Set": "GeneratedFunctions.set_as_hexwkb(%s, (byte) 4)", + "STBox": "GeneratedFunctions.stbox_out(%s, 15)", + "TBox": "GeneratedFunctions.tbox_out(%s, 15)", + "Cbuffer": "GeneratedFunctions.cbuffer_out(%s, 15)", + "Npoint": "GeneratedFunctions.npoint_out(%s, 15)", + "Nsegment": "GeneratedFunctions.nsegment_out(%s, 15)", + "Pose": "GeneratedFunctions.pose_out(%s, 15)", + "Jsonb": "GeneratedFunctions.jsonb_out(%s)", +} +# ── Scalar args: canonical -> (Spark DataType, Java boxed type, "parse expr") ── +SCALAR_ARG = { + "int": ("IntegerType", "Integer", "%s"), + "bool": ("BooleanType", "Boolean", "%s"), + "double": ("DoubleType", "Double", "%s"), + "int64_t": ("LongType", "Long", "%s"), + "uint64_t": ("LongType", "Long", "%s"), # 64-bit (H3Index/hash) <-> jnr long + "DateADT": ("IntegerType", "Integer", "%s"), # JMEOS maps DateADT -> int + "unsigned char": ("ByteType", "Byte", "%s"), # the WKB `variant` flag <-> jnr byte +} +# ── Scalar returns: canonical -> (Spark DataType, Java box, "serialize expr") ── +SCALAR_RET = { + "bool": ("BooleanType", "%s"), + "double": ("DoubleType", "%s"), + "int64_t": ("LongType", "%s"), + "uint64_t": ("LongType", "%s"), + "DateADT": ("IntegerType", "%s"), + "char *": ("StringType", "%s"), # cstring already a Java String via jnr + "text *": ("StringType", "GeneratedFunctions.text_out(%s)"), +} +# operators whose int (1/0/-1) result is a tri-state predicate -> BooleanType ==1 +PRED_OPS = {"?=", "?<>", "?<", "?<=", "?>", "?>=", + "%=", "%<>", "%<", "%<=", "%>", "%>=", + "#=", "#<>", "#<", "#<=", "#>", "#>="} +# genuinely-internal / non-user-facing base types -> legitimately OUT OF SCOPE. +INTERNAL = {"Datum", "SkipList", "GBOX", "BOX3D", "void", "meosType", "MeosType", + "uint8_t", "LWGEOM", "GEOSGeometry", "RTree", "interpType", "json_object", + "size_t", "Match", "TimeSplit", "FloatSplit", "FloatTimeSplit", + "IntSplit", "IntTimeSplit", "MvtGeom", "unsigned int", + "uint32", "Interval", "text", "char"} +# (Interval/text/char START as harder marshalling — deferred to a follow-up pass; +# counted as not-yet-emitted, NOT as a permanent exclusion. DateADT (->int) and +# TimestampTz (->OffsetDateTime) are now handled.) + + +# JMEOS actual signatures (name -> (javaRet, nArgs)), parsed from the jar in main(). +# The jar is the ground truth: it catches catalog/typerecover disagreements (uint64 +# collapsed to int, collapsed-jsonb int*, opaque PJ pointers) before they miscompile. +JSIG = {} +JPRIM = {"long": "LongType", "int": "IntegerType", "double": "DoubleType", + "boolean": "BooleanType", "float": "DoubleType"} + + +def base(canon): + t = norm(canon) + if "(*" in t or "()" in t or t.endswith("**"): + return "__INTERNAL__" + b = t.replace("*", "").strip() + return b + + +# pointer-to-primitive out-params: JMEOS drops the param, allocs a buffer, and +# returns a Pointer to it (the bool/void return is discarded). canonical -> deref. +OUTPRIM = { + "double *": ("DoubleType", "%s.getDouble(0)"), + "int *": ("IntegerType", "%s.getInt(0)"), + "int64_t *": ("LongType", "%s.getLongLong(0)"), + "bool *": ("BooleanType", "(%s.getByte(0) != 0)"), +} + + +def arg_kind(canon): + """('ptr', parse, KIND) | ('scalar', DataType, Box, expr) | ('ts',) | None.""" + nc = norm(canon) + b = base(canon) + if b == "TimestampTz" and nc == "TimestampTz": + return ("ts",) + if b in PARSE: + return ("ptr",) + PARSE[b] + # scalar ONLY when not a pointer: int* / DateADT* are arrays/out-params, not ints. + if b in SCALAR_ARG and "*" not in nc: + return ("scalar",) + SCALAR_ARG[b] + # C string: a single `const char *` is a Java String (jnr marshals it), passed + # straight to JMEOS — this is how the *_in(text) parsers take their WKT literal. + # (char** / multi-pointer stay unmapped; the jar arity cross-check guards mismatches.) + if b == "char" and nc.count("*") == 1: + return ("scalar", "StringType", "String", "%s") + return None + + +def classify(f): + """Split params into (in_params, out): a single trailing NON-const writable + pointer out-param on a bool/void function is dropped, and JMEOS returns a + Pointer to it. out is (DataType, serialize/deref-expr) or None. The out-param + may be a primitive (deref) or a struct in SERIAL (serialize). const pointers + are inputs, never out-params.""" + params = f["params"] + # A trailing non-const `size_t *` is the canonical buffer-length out-param of the + # *_as_wkb / *_as_hexwkb / *_as_ewkb family: JMEOS swallows it and returns the + # buffer (char* / byte[]) directly, so it is never a Java-visible parameter. + if params and "const" not in params[-1]["canonical"] and norm(params[-1]["canonical"]) == "size_t *": + params = params[:-1] + rt = norm(f["returnType"]["canonical"]) + if rt in ("bool", "void") and params: + lastc = params[-1]["canonical"] + lastn = norm(lastc) + writable = "const" not in lastc and lastn.endswith("*") + # no other writable out-param may precede it (single-out-param only) + others = [p for p in params[:-1] + if "const" not in p["canonical"] + and (norm(p["canonical"]) in OUTPRIM or base(p["canonical"]) in SERIAL) + and norm(p["canonical"]).endswith("*")] + if writable and not others: + if lastn in OUTPRIM: + return params[:-1], OUTPRIM[lastn] + if base(lastc) in SERIAL: + return params[:-1], ("StringType", SERIAL[base(lastc)]) + return params, None + + +def ret_emit(canon, sqlop): + """('ptr', DataType, serialize) | ('scalar', DataType, serialize) | None.""" + t = norm(canon) + b = base(t) + if b in SERIAL and t.endswith("*"): + return ("ptr", "StringType", SERIAL[b]) + if b == "TimestampTz": # JMEOS maps TimestampTz -> OffsetDateTime + return ("dt", "StringType", "UdfMarshal.tsOut(%s)") + if t == "int" or b == "int": + if sqlop in PRED_OPS: + return ("scalar", "BooleanType", "%s == 1") + return ("scalar", "IntegerType", "%s") + if t in SCALAR_RET: + return ("scalar",) + SCALAR_RET[t] + if b in SCALAR_RET: + return ("scalar",) + SCALAR_RET[b] + return None + + +def supported(f): + """Reason string if NOT emittable, else None.""" + # meos_internal_* doxygen groups are MEOS-internal, not user-facing — excluded. + if (f.get("group") or "").startswith("meos_internal"): + return "internal" + in_params, out = classify(f) + if out is None: + r = ret_emit(f["returnType"]["canonical"], f.get("sqlop")) + if r is None: + b = base(f["returnType"]["canonical"]) + return ("internal" if b in INTERNAL or b == "__INTERNAL__" else "ret:"+norm(f["returnType"]["canonical"])) + for p in in_params: + if arg_kind(p["canonical"]) is None: + b = base(p["canonical"]) + return ("internal" if b in INTERNAL or b == "__INTERNAL__" else "arg:"+norm(p["canonical"])) + # cross-check against the jar: my call arity must match JMEOS's. A mismatch means + # the catalog type disagrees with JMEOS (collapsed-jsonb int*, opaque PJ pointer, + # multi-out-param) — exclude rather than emit a call that won't bind. + if JSIG and f["name"] in JSIG and JSIG[f["name"]][1] != len(in_params): + return "arity:jmeos-mismatch" + # return-kind cross-check: if JMEOS returns a Pointer but my catalog-inferred + # return is a scalar (or vice versa), the catalog collapsed a type (LWGEOM/Jsonb + # -> int) — exclude rather than miscompile. + if out is None and JSIG and f["name"] in JSIG: + r = ret_emit(f["returnType"]["canonical"], f.get("sqlop")) + if (JSIG[f["name"]][0] == "jnr.ffi.Pointer") != (r[0] == "ptr"): + return "ret:jmeos-kind-mismatch" + return None + + +_JAVA_KEYWORDS = { + "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", + "class", "const", "continue", "default", "do", "double", "else", "enum", + "extends", "final", "finally", "float", "for", "goto", "if", "implements", + "import", "instanceof", "int", "interface", "long", "native", "new", "package", + "private", "protected", "public", "return", "short", "static", "strictfp", + "super", "switch", "synchronized", "this", "throw", "throws", "transient", + "try", "void", "volatile", "while", "true", "false", "null", "var", +} + + +def _javaid(n): + """A MEOS param name may collide with a Java keyword (e.g. synchronized).""" + return n + "_" if n in _JAVA_KEYWORDS else n + + +def class_for(group): + """Java class name for a doxygen @ingroup group. The group string is kept + literally (meos_ prefix stripped) so the same function lands in the same-named + class across tools. Functions with no @ingroup go to GeneratedUdfs_ungrouped.""" + g = group or "ungrouped" + if g.startswith("meos_"): + g = g[len("meos_"):] + return "GeneratedUdfs_" + g + + +# Default literals for SQL-OPTIONAL trailing args (params in [sqlArity, sqlArityMax)) +# that a generated UDF supplies so it can expose the SQL-required arity instead of the +# wider C one — e.g. asHexWKB(temporal) calls temporal_as_hexwkb(p, (byte) 4), +# trajectory(temporal) calls tpoint_trajectory(p, false). Only scalar flags are +# defaultable; if a hidden arg isn't here the UDF keeps the full C arity. +HIDE_DEFAULT = {"bool": "false", "unsigned char": "(byte) 4", "int": "0", + "double": "0.0", "int64_t": "0L", "uint64_t": "0L"} + + +def emit_single(name, f, vis_arity=None): + params, out = classify(f) + # SQL-faithful arity: expose only the first vis_arity params, supplying HIDE_DEFAULT + # literals for the optional trailing flags. Fall back to the full C arity if any + # hidden arg has no known default. + hidden = [] + if vis_arity is not None and 0 <= vis_arity < len(params): + tail = params[vis_arity:] + if all(base(p["canonical"]) in HIDE_DEFAULT and "*" not in norm(p["canonical"]) for p in tail): + hidden = tail + params = params[:vis_arity] + if out is None: + r = ret_emit(f["returnType"]["canonical"], f.get("sqlop")) + ret_dt, ret_ser, ret_ptr, ret_out = r[1], r[2], (r[0] == "ptr"), False + # trust the jar for plain numeric returns: the catalog collapses uint64->int, + # but JMEOS exposes the true width (e.g. *_hash_extended returns long). + if r[0] == "scalar" and ret_ser == "%s" and name in JSIG and JSIG[name][0] in JPRIM: + ret_dt = JPRIM[JSIG[name][0]] + else: + ret_dt, ret_ser, ret_ptr, ret_out = out[0], out[1], False, True + box = {"IntegerType": "Integer", "DoubleType": "Double", "BooleanType": "Boolean", + "LongType": "Long", "StringType": "String"}[ret_dt] + argnames = [_javaid(p["name"] or ("a%d" % i)) for i, p in enumerate(params)] + argboxes, kinds = [], [] + for p in params: + k = arg_kind(p["canonical"]) + kinds.append(k) + argboxes.append({"ptr": "String", "ts": "Object", "scalar": k[2] if k[0] == "scalar" else "String"}[k[0]]) + iface = "UDF%d<%s, %s>" % (len(params), ", ".join(argboxes), box) if params else "UDF0<%s>" % box + # Emit as an inline lambda inside a register() call (NOT a static field): 2349 + # static-field initializers overrun the 64 KB bytecode limit. Inline + # lambdas compile to separate synthetic methods, keeping the chunk method small. + L = [f' spark.udf().register("{name}", ({iface}) (' + ", ".join(argnames) + ") -> {" + if params else f' spark.udf().register("{name}", ({iface}) () -> {{'] + if argnames: + L.append(" if (" + " || ".join(f"{a} == null" for a in argnames) + ") return null;") + L.append(" MeosThread.ensureReady();") + callargs, frees = [], [] + for a, p, k in zip(argnames, params, kinds): + if k[0] == "ptr": + parse = k[1] + L.append(f" jnr.ffi.Pointer p_{a} = {parse % a};") + L.append(f" if (p_{a} == null) return null;") + callargs.append(f"p_{a}"); frees.append(f"p_{a}") + elif k[0] == "ts": + L.append(f" java.time.OffsetDateTime dt_{a} = UdfMarshal.tsOdt({a});") + callargs.append(f"dt_{a}") + else: + callargs.append(a) + # supply default literals for the SQL-hidden trailing flags (sqlArity..C-arity) + for p in hidden: + callargs.append(HIDE_DEFAULT[base(p["canonical"])]) + call = f"GeneratedFunctions.{f['name']}(" + ", ".join(callargs) + ")" + L.append(" try {") + if ret_out: + # JMEOS returns a jnr-allocated buffer (GC-managed) — deref, never free it. + L.append(f" jnr.ffi.Pointer _r = {call};") + L.append(" if (_r == null) return null;") + L.append(f" return {ret_ser % '_r'};") + elif ret_ptr: + L.append(f" jnr.ffi.Pointer _r = {call};") + L.append(" if (_r == null) return null;") + L.append(f" try {{ return {ret_ser % '_r'}; }} finally {{ MeosMemory.free(_r); }}") + else: + L.append(f" return {ret_ser % call};") + L.append(" } finally {") + for fr in frees: + L.append(f" MeosMemory.free({fr});") + L.append(" }") + L.append(f" }}, DataTypes.{ret_dt});") + return "\n".join(L) + + +_RETBOX = {"IntegerType": "Integer", "DoubleType": "Double", "BooleanType": "Boolean", + "LongType": "Long", "StringType": "String", "ByteType": "Byte"} + + +def _sig(f): + """The Spark-marshalled SIGNATURE of an emittable function: (arg-slot tuple, + return-shape). Two functions with the SAME _sig present an identical Java UDF + interface, so several C overloads of one @sqlfn name that share a _sig can be + dispatched by ONE Spark UDF. Slot = the Java box for a scalar arg, "P" for any + pointer arg (always a String), "T" for a timestamp. Returns None if unemittable.""" + params, out = classify(f) + slots = [] + for p in params: + k = arg_kind(p["canonical"]) + if k is None: + return None + slots.append("P" if k[0] == "ptr" else ("T" if k[0] == "ts" else k[2])) + if out is not None: + ret = ("out", out[0], out[1]) + else: + r = ret_emit(f["returnType"]["canonical"], f.get("sqlop")) + if r is None: + return None + ret = (("ptr" if r[0] == "ptr" else "scalar"), r[1], r[2]) + return (tuple(slots), ret) + + +def _safe_dispatch(f): + """A function is safely arg-kind-dispatchable only if every pointer arg parses via a + type-safe hex-WKB wrapper (UdfMarshal.*FromHex, which checks the WKB type byte and + returns null on a foreign family) or the validating WKT/EWKT parser + (UdfMarshal.geoFromText, which delegates to geo_from_text and returns null on a + foreign string). The text *_in parsers (stbox_in / tbox_in / cbuffer_in / npoint_in / + pose_in / jsonb_in) are NOT: fed a hex-WKB or WKT string they may mis-parse, so an + overload using one cannot be told apart at runtime and must not enter a dispatcher.""" + for p in classify(f)[0]: + k = arg_kind(p["canonical"]) + if k and k[0] == "ptr" and "FromHex" not in k[1] and "geoFromText" not in k[1]: + return False + return True + + +def _parsetuple(f): + """The arg KINDS that a runtime parse can actually DISTINGUISH: K_TEMPORAL / K_GEO / + K_SPAN ... for pointer args, a constant marker for scalars/timestamps. Two overloads + with the SAME _parsetuple differ only by temporal SUBTYPE (tdistance_tgeo_tgeo vs + tdistance_tnpoint_tnpoint — both (Temporal,Temporal)) and so CANNOT be told apart by + parsing the hex-WKB; only one of them may go into a parse-based dispatcher.""" + out = [] + for p in classify(f)[0]: + k = arg_kind(p["canonical"]) + out.append(k[2] if k[0] == "ptr" else ("TS" if k[0] == "ts" else "S")) + return tuple(out) + + +# Among parse-indistinguishable overloads, prefer the geometry family the canonical +# BerlinMOD suite (and most users) call: tgeo / geo. Lower rank = more preferred. +_FAMTOK = ["_tgeo_", "tgeo_", "_geo_", "_geo", "geo_", "temporal_", "_tspatial_", "tpoint", "tnumber"] +def _famrank(f): + n = f["name"] + return next((i for i, t in enumerate(_FAMTOK) if t in n), len(_FAMTOK)) + + +def emit_dispatch(name, cands, vis_arity=None): + """Emit ONE Spark UDF for an @sqlfn name backed by SEVERAL C overloads that share + a _sig (e.g. eIntersects <- eintersects_tgeo_tgeo / _tgeo_geo / _geo_tgeo). Spark + cannot overload a UDF name, so the single lambda parses each pointer arg with each + candidate's parsers in turn: the FIRST candidate whose every pointer arg parses is + the matching overload (the hex-WKB / WKT / span parsers are mutually discriminating, + so exactly one matches). Parse-all-then-check keeps it leak-free on every path. + vis_arity (SQL-required arity) exposes only the first N args, supplying HIDE_DEFAULT + literals for the optional trailing flags (shared across the overloads via _sig).""" + rep = cands[0] + slots, ret = _sig(rep) + n = len(slots) + vis = n + rep_params = classify(rep)[0] + if vis_arity is not None and 0 <= vis_arity < n: + tail = rep_params[vis_arity:] + if all(base(p["canonical"]) in HIDE_DEFAULT and "*" not in norm(p["canonical"]) for p in tail): + vis = vis_arity + slots = slots[:vis] + n = vis + argnames = ["a%d" % i for i in range(n)] + argboxes = [("String" if s == "P" else ("Object" if s == "T" else s)) for s in slots] + ret_kind, ret_dt, ret_ser = ret + box = _RETBOX[ret_dt] + iface = "UDF%d<%s, %s>" % (n, ", ".join(argboxes), box) if n else "UDF0<%s>" % box + L = [' spark.udf().register("%s", (%s) (%s) -> {' % (name, iface, ", ".join(argnames))] + if argnames: + L.append(" if (" + " || ".join("%s == null" % a for a in argnames) + ") return null;") + L.append(" MeosThread.ensureReady();") + # order GEO/WKT-parsing candidates LAST so the strict hex parsers get first refusal + def geocount(f): + return sum(1 for p in classify(f)[0] if base(p["canonical"]) == "GSERIALIZED") + for f in sorted(cands, key=geocount): + cps = classify(f)[0] + ks = [arg_kind(p["canonical"]) for p in cps] + callargs, ptrs = [], [] + L.append(" {") + for a, k in zip(argnames, ks): + if k[0] == "ptr": + pv = "P_%s" % a + parse = k[1] % a + # a hex-WKB parser CRASHES on non-hex input — gate it on isHex so a WKT + # geometry literal falls through to the geo_from_text candidate instead. + if "from_hexwkb" in k[1]: + parse = "UdfMarshal.isHex(%s) ? %s : null" % (a, parse) + L.append(" jnr.ffi.Pointer %s = %s;" % (pv, parse)) + ptrs.append(pv); callargs.append(pv) + elif k[0] == "ts": + L.append(" java.time.OffsetDateTime D_%s = UdfMarshal.tsOdt(%s);" % (a, a)) + callargs.append("D_%s" % a) + else: + callargs.append(a) + # SQL-hidden trailing flags get default literals (zip above paired only the + # first `vis` exposed args; the candidate's remaining params are the flags). + for p in cps[vis:]: + callargs.append(HIDE_DEFAULT[base(p["canonical"])]) + cond = " && ".join("%s != null" % p for p in ptrs) if ptrs else "true" + free = " ".join("MeosMemory.free(%s);" % p for p in ptrs) + call = "GeneratedFunctions.%s(%s)" % (f["name"], ", ".join(callargs)) + L.append(" if (%s) {" % cond) + if ret_kind == "out": + L.append(" jnr.ffi.Pointer _r = %s;" % call) + L.append(" try { return _r == null ? null : %s; } finally { %s }" % (ret_ser % "_r", free)) + elif ret_kind == "ptr": + L.append(" jnr.ffi.Pointer _r = %s;" % call) + L.append(" try { return _r == null ? null : %s; } finally { MeosMemory.free(_r); %s }" % (ret_ser % "_r", free)) + else: + L.append(" try { return %s; } finally { %s }" % (ret_ser % call, free)) + L.append(" }") + for p in ptrs: + L.append(" if (%s != null) MeosMemory.free(%s);" % (p, p)) + L.append(" }") + L.append(" return null;") + L.append(" }, DataTypes.%s);" % ret_dt) + return "\n".join(L) + + +def emit_timearg(name, op): + """Emit the time-restrict polymorphic UDF (atTime / minusTime): the time arg is a + String classified at runtime (timestamp / period / set / span set) and routed to the + matching temporal__{timestamptz,tstzspan,tstzset,tstzspanset} backing — Spark + cannot overload a UDF name by the time arg's type.""" + refs = ", ".join("GeneratedFunctions::temporal_%s_%s" % (op, k) + for k in ("timestamptz", "tstzspan", "tstzset", "tstzspanset")) + return (' spark.udf().register("%s", (UDF2) (a, b) -> {\n' + ' if (a == null || b == null) return null;\n' + ' MeosThread.ensureReady();\n' + ' jnr.ffi.Pointer t = UdfMarshal.tFromHex(a);\n' + ' if (t == null) return null;\n' + ' try { return UdfMarshal.restrictTime(t, b, %s); }\n' + ' finally { MeosMemory.free(t); }\n' + ' }, DataTypes.StringType);' % (name, refs)) + + +def tgeoarr_shape(f): + """Recognize a MEOS NxN array kernel — params are one or more (Temporal **, int) + array pairs, an optional `double` (distance), and optional non-const out-params + (int *count, SpanSet ***periods). Returns a shape dict or None. + ret: 'double' (scalar, e.g. minDistance) | 'pairs' (int* of 2*count [i,j], e.g. the + *Pairs functions). periods=True iff a SpanSet*** out-param is present (tDwithin).""" + ps = f["params"] + n = len(ps) + i = arrays = 0 + dist = has_count = periods = False + while i < n: + c = norm(ps[i]["canonical"]); isconst = "const" in ps[i]["canonical"] + bare = c.replace("*", "").strip() # base() maps ** -> __INTERNAL__, so strip here + if bare == "Temporal" and c.endswith("**"): + if i + 1 < n and norm(ps[i + 1]["canonical"]) == "int": + arrays += 1; i += 2; continue + return None + if c == "double": + dist = True; i += 1; continue + if c == "int *" and not isconst: + has_count = True; i += 1; continue + if bare == "SpanSet" and c.count("*") == 3 and not isconst: + periods = True; i += 1; continue + return None + if arrays < 1: + return None + rt = norm(f["returnType"]["canonical"]) + ret = "double" if rt == "double" else ("pairs" if rt == "int *" else None) + if ret is None or (ret == "pairs" and not has_count): + return None + return {"arrays": arrays, "dist": dist, "periods": periods, "ret": ret} + + +def emit_tgeoarr(name, f, shape): + """Emit a Spark UDF for an NxN array kernel. Each (Temporal**, int) pair becomes one + Spark array arg (the count is the array length); an optional `double` distance + is a Double arg; out-params (count / periods) are auto-allocated. Scalar-return kernels + yield a Double UDF; pairs-return kernels yield array> (consumed via + LATERAL explode), with MEOS 1-based indices mapped to 0-based.""" + nA = shape["arrays"] + argnames = ["a%d" % i for i in range(nA)] + (["dist"] if shape["dist"] else []) + # dist arrives as Object: a bare SQL literal like 10.0 is decimal (BigDecimal), not + # double, so take it as Object and coerce via Number rather than failing the cast. + boxes = ["Object"] * nA + (["Object"] if shape["dist"] else []) + if shape["ret"] == "double": + retbox, ret_dt = "Double", "DataTypes.DoubleType" + else: + fields = ['DataTypes.createStructField("i", DataTypes.IntegerType, false)', + 'DataTypes.createStructField("j", DataTypes.IntegerType, false)'] + if shape["periods"]: + fields.append('DataTypes.createStructField("periods", DataTypes.StringType, true)') + struct = "DataTypes.createStructType(new org.apache.spark.sql.types.StructField[]{%s})" % ", ".join(fields) + retbox, ret_dt = "java.util.List", "DataTypes.createArrayType(%s)" % struct + iface = "UDF%d<%s, %s>" % (len(argnames), ", ".join(boxes), retbox) + L = [' spark.udf().register("%s", (%s) (%s) -> {' % (name, iface, ", ".join(argnames))] + L.append(" if (" + " || ".join("a%d == null" % i for i in range(nA)) + ") return null;") + L.append(" MeosThread.ensureReady();") + for i in range(nA): + L.append(" String[] s%d = UdfMarshal.asStrArray(a%d);" % (i, i)) + L.append(" if (" + " || ".join("s%d == null" % i for i in range(nA)) + ") return null;") + L.append(" jnr.ffi.Runtime _rt = jnr.ffi.Runtime.getSystemRuntime();") + for i in range(nA): + L.append(" jnr.ffi.Pointer[] e%d = new jnr.ffi.Pointer[s%d.length];" % (i, i)) + L.append(" jnr.ffi.Pointer arr%d = UdfMarshal.tArrNative(s%d, e%d, _rt);" % (i, i, i)) + callargs = [] + for i in range(nA): + callargs += ["arr%d" % i, "s%d.length" % i] + if shape["dist"]: + callargs.append("dist == null ? 0.0 : ((Number) dist).doubleValue()") + if shape["ret"] == "pairs": + L.append(" jnr.ffi.Pointer _cnt = jnr.ffi.Memory.allocateDirect(_rt, 4);") + callargs.append("_cnt") + if shape["periods"]: + L.append(" jnr.ffi.Pointer _per = jnr.ffi.Memory.allocateDirect(_rt, 8);") + callargs.append("_per") + call = "GeneratedFunctions.%s(%s)" % (f["name"], ", ".join(callargs)) + L.append(" try {") + if shape["ret"] == "double": + L.append(" return %s;" % call) + else: + L.append(" jnr.ffi.Pointer _res = %s;" % call) + L.append(" int _c = _cnt.getInt(0L);") + if shape["periods"]: + L.append(" return UdfMarshal.readPairsPeriods(_res, _c, _per.getPointer(0L));") + else: + L.append(" return UdfMarshal.readPairs(_res, _c);") + L.append(" } finally {") + for i in range(nA): + L.append(" UdfMarshal.freeArr(e%d);" % i) + L.append(" }") + L.append(" }, %s);" % ret_dt) + return "\n".join(L) + + +GEN_NOTE = "// GENERATED by tools/codegen_spark_udfs.py from the MEOS-API catalog. DO NOT EDIT.\n" +IMPORTS = """\ +package org.mobilitydb.spark.generated; + +import functions.GeneratedFunctions; +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; +""" + +# Shared marshalling helpers live in their own class: the 2300+ UDFs are partitioned +# across many Part classes (a single class overruns the 64 KB method / constant-pool +# limits — exactly why JMEOS splits GeneratedFunctions into MeosLibraryPartA/PartB). +MARSHAL = GEN_NOTE + """\ +package org.mobilitydb.spark.generated; + +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.util.function.BiFunction; +import jnr.ffi.Memory; +import jnr.ffi.Pointer; +import jnr.ffi.Runtime; +import org.apache.spark.sql.Row; +import org.apache.spark.sql.RowFactory; +import functions.GeneratedFunctions; +import org.mobilitydb.spark.MeosMemory; +import org.mobilitydb.spark.MeosThread; + +final class UdfMarshal { + private UdfMarshal() {} + private static final DateTimeFormatter PG_TZ = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssXX"); + // JMEOS marshals TimestampTz as java.time.OffsetDateTime. + static java.time.OffsetDateTime tsOdt(Object a) { + if (a instanceof java.sql.Timestamp) + return ((java.sql.Timestamp) a).toInstant().atOffset(ZoneOffset.UTC); + if (a instanceof java.time.OffsetDateTime) return (java.time.OffsetDateTime) a; + if (a instanceof java.time.Instant) return ((java.time.Instant) a).atOffset(ZoneOffset.UTC); + // A String timestamp: MEOS owns TZ resolution (ecosystem-uniform, like SRID via + // geo_from_text) — parse via pg_timestamptz_in, NEVER a Java/Spark offset fixup. + return GeneratedFunctions.pg_timestamptz_in(a.toString().trim(), -1); + } + static String tsOut(java.time.OffsetDateTime t) { + return t == null ? null : t.format(PG_TZ); + } + + // A hex-WKB string is an even-length run of hex digits. The overload dispatchers + // must check this BEFORE handing a String to a *_from_hexwkb parser: MEOS's hex + // decoder crashes (not returns null) on non-hex bytes, so trying a temporal parser + // on a WKT geometry literal would segfault. WKT fails isHex (it has letters like + // 'L','I','N','(' that are not hex digits), so the dispatch falls through to the + // geo_from_text branch instead. + static boolean isHex(String s) { + int n = s.length(); + if (n == 0 || (n & 1) != 0) return false; + for (int i = 0; i < n; i++) + if (Character.digit(s.charAt(i), 16) < 0) return false; + return true; + } + + // Geometry/geography arg parse. The canonical wire form is EWKT + // ("SRID=4326;POLYGON(...)") so the SRID survives to MEOS — but geo_from_text() is + // WKT-only and returns null on the "SRID=" prefix, dropping the SRID (which H3 / + // geo_to_h3index_set REQUIRE via ensure_srid_is_latlong). Split the prefix and pass + // its value as geo_from_text's srid argument; plain WKT (no prefix) parses at SRID 0. + // CRITICAL for overload dispatch: reject a pure-hex string up front. geo_from_text() + // also accepts hex-(E)WKB, so a temporal/set hex-WKB arg (a tgeompoint trip) would be + // MIS-READ as a geometry (garbage npoints / free() crash) when a (geo, tgeo) candidate + // is tried before the (tgeo, geo) one. A real WKT/EWKT geometry ALWAYS contains + // non-hex chars (P O L Y G N '(' '=' ';' ...), so isHex(s) is false for it; only a + // foreign WKB hex is pure-hex — exactly what must fall through to the next candidate. + static Pointer geoFromText(String s) { + if (s == null || isHex(s)) return null; + int srid = 0; String wkt = s; + if (s.length() > 5 && s.regionMatches(true, 0, "SRID=", 0, 5)) { + int semi = s.indexOf(';'); + if (semi > 5) { + try { srid = Integer.parseInt(s.substring(5, semi).trim()); wkt = s.substring(semi + 1); } + catch (NumberFormatException e) { srid = 0; wkt = s; } + } + } + return GeneratedFunctions.geo_from_text(wkt, srid); + } + + // ── NxN array (tgeoarr) marshalling ────────────────────────────────────────── + // The MEOS *_tgeoarr_tgeoarr kernels take (Temporal **arr, int n) array pairs and + // run the whole NxN inside C. Spark passes array as a scala Seq / WrappedArray + // (or a java List), so normalize to String[] first. + static String[] asStrArray(Object o) { + if (o == null) return null; + if (o instanceof scala.collection.Seq) { + scala.collection.Seq q = (scala.collection.Seq) o; + String[] r = new String[q.length()]; + for (int i = 0; i < r.length; i++) { Object e = q.apply(i); r[i] = e == null ? null : e.toString(); } + return r; + } + if (o instanceof java.util.List) { + java.util.List l = (java.util.List) o; + String[] r = new String[l.size()]; + for (int i = 0; i < r.length; i++) { Object e = l.get(i); r[i] = e == null ? null : e.toString(); } + return r; + } + if (o instanceof Object[]) { + Object[] a = (Object[]) o; String[] r = new String[a.length]; + for (int i = 0; i < r.length; i++) r[i] = a[i] == null ? null : a[i].toString(); + return r; + } + return null; + } + // Parse a hex-temporal array into a native Temporal** buffer; the parsed element + // pointers are stored in `elems` (parallel) so the caller frees them after the call. + static Pointer tArrNative(String[] hex, Pointer[] elems, Runtime rt) { + Pointer buf = Memory.allocateDirect(rt, Math.max(1, hex.length) * 8); + for (int i = 0; i < hex.length; i++) { + Pointer p = (hex[i] != null && isHex(hex[i])) ? GeneratedFunctions.temporal_from_hexwkb(hex[i]) : null; + elems[i] = p; + buf.putPointer((long) i * 8L, p); + } + return buf; + } + static void freeArr(Pointer[] elems) { for (Pointer p : elems) MeosMemory.free(p); } + // A *_tgeoarr_tgeoarr kernel returns a flat int* of 2*count [i,j] index pairs (caller + // frees). The C kernel uses 0-based C indices (the PG SETOF wrapper is what makes them + // 1-based) — and the Spark UDF calls the kernel directly via JMEOS, so the indices are + // already 0-based array offsets; emit them as-is (matching MeosSetSetJoin). + static java.util.List readPairs(Pointer res, int cnt) { + java.util.ArrayList out = new java.util.ArrayList<>(); + if (res == null || cnt <= 0) return out; + for (int k = 0; k < cnt; k++) + out.add(RowFactory.create(res.getInt((long) (2 * k) * 4L), + res.getInt((long) (2 * k + 1) * 4L))); + MeosMemory.free(res); + return out; + } + // tDwithin also returns a parallel SpanSet** of the per-pair intersection periods + // (via a SpanSet ***out-param); render each as hex-WKB. Frees res, the periods array, + // and each period span set. + static java.util.List readPairsPeriods(Pointer res, int cnt, Pointer ssArr) { + java.util.ArrayList out = new java.util.ArrayList<>(); + if (res == null || cnt <= 0) { MeosMemory.free(res); return out; } + for (int k = 0; k < cnt; k++) { + Pointer ss = ssArr == null ? null : ssArr.getPointer((long) k * 8L); + String periods = ss == null ? null : GeneratedFunctions.spanset_as_hexwkb(ss, (byte) 0); + out.add(RowFactory.create(res.getInt((long) (2 * k) * 4L), + res.getInt((long) (2 * k + 1) * 4L), periods)); + MeosMemory.free(ss); + } + MeosMemory.free(ssArr); + MeosMemory.free(res); + return out; + } + + // True iff a hex-WKB temporal pointer is a tnumber (tint/tfloat): only those have + // a TBox value extent. Used SOLELY to select which existing backing to delegate to + // for the axis-ambiguous space-X operators — never to compute a result. + private static boolean isTnumber(Pointer p) { + Pointer box = GeneratedFunctions.tnumber_to_tbox(p); + if (box == null) return false; + MeosMemory.free(box); + return true; + } + + // Space-X (<<, >>, &<, &>): the value-axis (tnumber) and the X-axis (tspatial) are + // distinct C operators. Parse both args once, then dispatch to the tnumber backing + // for a tnumber left arg, else the tspatial backing. Both delegates are the + // operator's own existing MEOS symbols — no operator logic here. + static Boolean axisBool(String s1, String s2, + BiFunction tnumber, + BiFunction tspatial) { + if (s1 == null || s2 == null) return null; + MeosThread.ensureReady(); + Pointer p1 = tFromHex(s1); + if (p1 == null) return null; + Pointer p2 = tFromHex(s2); + if (p2 == null) { MeosMemory.free(p1); return null; } + try { + return isTnumber(p1) ? tnumber.apply(p1, p2) : tspatial.apply(p1, p2); + } finally { + MeosMemory.free(p1); + MeosMemory.free(p2); + } + } + + // ── Type-SAFE hex-WKB parsing ──────────────────────────────────────────────── + // A *_from_hexwkb parser reads the MEOS WKB structure for ONE type family and + // SEGV-crashes on a valid-hex buffer of a different family (a tstzspan hex fed to + // temporal_from_hexwkb). The WKB type lives in byte 1 (= the MeosType enum value), + // so read it first and only call the C parser when the family matches. These sets + // are generated from the catalog's MeosType enum (data-driven, no hardcoding). +__WKB_KINDS__ + // The MeosType byte = the 2nd WKB byte (hex chars [2,4)). -1 if not a hex-WKB string. + static int wkbType(String s) { + if (s == null || s.length() < 4 || !isHex(s)) return -1; + return Character.digit(s.charAt(2), 16) * 16 + Character.digit(s.charAt(3), 16); + } + static Pointer tFromHex(String s) { + return TEMPORAL_WKB.contains(wkbType(s)) ? GeneratedFunctions.temporal_from_hexwkb(s) : null; + } + static Pointer spanFromHex(String s) { + return SPAN_WKB.contains(wkbType(s)) ? GeneratedFunctions.span_from_hexwkb(s) : null; + } + static Pointer spansetFromHex(String s) { + return SPANSET_WKB.contains(wkbType(s)) ? GeneratedFunctions.spanset_from_hexwkb(s) : null; + } + static Pointer setFromHex(String s) { + return SET_WKB.contains(wkbType(s)) ? GeneratedFunctions.set_from_hexwkb(s) : null; + } + + // Time-restrict polymorphism (atTime / minusTime): MobilityDB resolves the time arg + // by type (timestamptz / tstzspan / tstzset / tstzspanset), but Spark cannot overload + // a UDF name. The arg arrives as a String — classify it by its first char (a period + // "[..]", a set "{..}", a span set "{[..],..}", else a bare timestamp) and route to + // the matching MEOS overload, returning the restricted temporal as hex-WKB. + static String restrictTime(Pointer t, String arg, + BiFunction byTs, + BiFunction bySpan, + BiFunction bySet, + BiFunction bySpanset) { + String s = arg.trim(); + Pointer r; + if (s.startsWith("{")) { + boolean spanset = s.indexOf('[') >= 0 || s.indexOf('(') >= 0; + Pointer p = spanset ? GeneratedFunctions.tstzspanset_in(s) : GeneratedFunctions.tstzset_in(s); + if (p == null) return null; + try { r = (spanset ? bySpanset : bySet).apply(t, p); } finally { MeosMemory.free(p); } + } else if (s.startsWith("[") || s.startsWith("(")) { + Pointer p = GeneratedFunctions.tstzspan_in(s); + if (p == null) return null; + try { r = bySpan.apply(t, p); } finally { MeosMemory.free(p); } + } else { + r = byTs.apply(t, tsOdt(s)); + } + if (r == null) return null; + try { return GeneratedFunctions.temporal_as_hexwkb(r, (byte) 4); } finally { MeosMemory.free(r); } + } +} +""" + + +def main(): + ap = argparse.ArgumentParser() + here = os.path.dirname(os.path.abspath(__file__)) + ap.add_argument("--catalog", default=os.path.join(here, "..", "..", "MEOS-API", "output", "meos-idl.json")) + # Default into the maven build dir (NOT a source root): build-time generation + # owns target/; a bare run must never pollute src/ (which would double-compile). + ap.add_argument("--out", default=os.path.join( + here, "..", "target", "generated-sources", "spark", + "org", "mobilitydb", "spark", "generated")) + ap.add_argument("--jar", default=os.path.join(here, "..", "libs", "JMEOS-1.4.jar"), + help="JMEOS jar; only functions JMEOS actually exposes are emitted " + "(catalog is a superset incl. internal _addmat/above8D/GEOS macros)") + ap.add_argument("--report", action="store_true") + args = ap.parse_args() + + cat = json.load(open(args.catalog)) + fns = cat["functions"] + + # The catalog is the raw extern parse of the MobilityDB headers; JMEOS curates + # its public surface (e.g. drops matrix internals _addmat/_choldc1, RTree node + # predicates above8D/adjacent2D, GEOS conv macros MEOS_GEOS2POSTGIS). Emit ONLY + # what JMEOS exposes, so a generated UDF can never call an absent jar symbol. + jar_syms = None + if args.jar and os.path.exists(args.jar): + import subprocess, re + jv = subprocess.run(["javap", "-p", "-cp", args.jar, "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + jar_syms = set(re.findall(r"\b([a-z][A-Za-z0-9_]+)\(", jv)) + # JSIG: name -> (javaReturnType, nArgs) — the jar's actual signatures. + for m in re.finditer(r"public static (\S+) ([a-z][A-Za-z0-9_]+)\(([^)]*)\)", jv): + jret, jname, jargs = m.group(1), m.group(2), m.group(3).strip() + JSIG[jname] = (jret if "." in jret else jret.lower(), + 0 if not jargs else len(jargs.split(","))) + + # GOAL: reach the WHOLE JMEOS surface. Every MEOS C function (unique by its C + # name) becomes a 1:1 UDF named by that C symbol — that is how the ~2254 + # functions with no @sqlfn are reached. The portable dialect (@sqlfn / operator + # bare names from the contract) is layered on top in a later dispatch pass. + grouped, names, cov = {}, set(), 0 + skips = collections.Counter() + internal = total = not_in_jar = 0 + + for f in fns: + name = f["name"] + if jar_syms is not None and name not in jar_syms: + not_in_jar += 1 # internal helper JMEOS doesn't expose — skip + continue + total += 1 + if name in names: + continue + why = supported(f) + if why: + if why == "internal": + internal += 1 + else: + skips[why] += 1 + continue + grouped.setdefault(class_for(f.get("group")), []).append(emit_single(name, f)) + names.add(name) + cov += 1 + + # ── DISPATCH PASS: portable bare names from the contract families ── + # Spark cannot overload by name, but MEOS exposes SUPERCLASS entrypoints that + # dispatch every concrete temporal type internally from the type-erased hex-WKB + # string. So a portable bare name (eEq, tLt, aGe — RFC #920 / contract #19) wraps its + # superclass *_temporal_temporal C symbol for ALL temporal subtypes. But some eEq/eNe + # overloads have a NON-temporal first arg — eEq(geo, tgeo), and the th3 cell-set + # prefilter eEq(h3indexset, th3index) whose first arg is a Set* — which the Temporal* + # superclass cannot reach. Gather those (same 2-pointer-Boolean signature, distinct + # parse-tuple, dispatch-safe) and emit ONE parse-dispatching UDF so they resolve too. + by_name = {f["name"]: f for f in fns} + fams = (cat.get("portableAliases") or {}).get("families", {}) + SUF = {"Eq": "eq", "Ne": "ne", "Lt": "lt", "Le": "le", "Gt": "gt", "Ge": "ge"} + DISPATCH = [("everComparison", "ever_%s_temporal_temporal"), + ("alwaysComparison", "always_%s_temporal_temporal"), + ("temporalComparison", "temporal_%s")] + ndisp = 0 + for fam, pat in DISPATCH: + for e in fams.get(fam, []): + bare = e["bareName"] + suf = next((v for k, v in SUF.items() if bare.endswith(k)), None) + backing = by_name.get(pat % suf) if suf else None + if not (backing and supported(backing) is None): + continue + # Non-temporal overloads under the SAME @sqlfn bare name (geo/set first arg), + # sharing the superclass's (P,P)->Boolean signature, each parse-distinct. + rep_sig = _sig(backing) + cands, seen = [backing], {_parsetuple(backing)} + extras = [f for f in fns + if f.get("sqlfn") == bare and f["name"] != backing["name"] + and supported(f) is None and _safe_dispatch(f) + and _sig(f) == rep_sig] + for f in sorted(extras, key=_famrank): + pt = _parsetuple(f) + if pt not in seen: + seen.add(pt) + cands.append(f) + emit = emit_single(bare, backing) if len(cands) == 1 else emit_dispatch(bare, cands) + grouped.setdefault("GeneratedUdfs_portable_comparison", []).append(emit) + ndisp += 1 + cov += 1 + print(" dispatch bare names (comparison) : %d" % ndisp, file=sys.stderr) + + # ── bare-name-IS-prefix families: topology / same / time / space Y,Z ── + # Each contract bareName IS the MEOS C operator prefix, and the superclass + # entrypoint *_temporal_temporal (time/topology) or *_tspatial_tspatial (spatial + # position) dispatches every concrete subtype internally from the type-erased + # hex-WKB — so one emit covers all six type families. Same emit machinery as the + # comparison dispatch; only the backing-name pattern differs. + PREFIX = [("same", "%s_temporal_temporal"), + ("timePosition", "%s_temporal_temporal"), + ("spaceY", "%s_tspatial_tspatial"), + ("spaceZ", "%s_tspatial_tspatial")] + nbare = 0 + for fam, pat in PREFIX: + for e in fams.get(fam, []): + bare = e["bareName"] + backing = by_name.get(pat % bare) + if backing and supported(backing) is None: + grouped.setdefault("GeneratedUdfs_portable_operator", []).append( + emit_single(bare, backing)) + nbare += 1 + cov += 1 + # topology (&&, @>, <@, -|-) is polymorphic over SPANS and TEMPORALS: overlaps( + # tstzspan, tstzspan) = overlaps_span_span, overlaps(tgeompoint, ...) = + # overlaps_temporal_temporal. Dispatch across both — the type-safe WKB parsers route a + # span (e.g. from timeSpan()) to the span backing instead of crashing the temporal one. + for e in fams.get("topology", []): + bare = e["bareName"] + cands = [by_name.get(bare + "_span_span"), by_name.get(bare + "_temporal_temporal")] + cands = [f for f in cands if f and supported(f) is None] + if not cands: + continue + code = emit_single(bare, cands[0]) if len(cands) == 1 else emit_dispatch(bare, cands) + grouped.setdefault("GeneratedUdfs_portable_operator", []).append(code) + nbare += 1 + cov += 1 + print(" dispatch bare names (operator) : %d" % nbare, file=sys.stderr) + + # (distance — tdistance / nearestApproachDistance — is NOT registered here: those + # carry @sqlfn tags (tDistance / nearestApproachDistance) with several typed C + # overloads, so the @sqlfn pass below emits them with full arg-kind dispatch — a + # single tgeo_geo backing here would wrongly null a trip-vs-trip call.) + + # ── space X (<<, >>, &<, &>): the ONE axis-ambiguous family ── + # left/right/overleft/overright resolve to DIFFERENT C symbols by argument class + # — the tnumber value-axis (left_tnumber_tnumber) vs. the tspatial X-axis + # (left_tspatial_tspatial). A thin runtime classifier (UdfMarshal.axisBool, which + # inspects whether arg1 is a tnumber) SELECTS between the two existing backings; + # it contains no operator logic, so equivalence-by-construction holds. This is the + # only family that needs a per-arg type inspection, exactly as the contract notes. + naxis = 0 + for e in fams.get("spaceX", []): + bare = e["bareName"] + tnum, tspat = by_name.get("%s_tnumber_tnumber" % bare), by_name.get("%s_tspatial_tspatial" % bare) + if tnum and tspat and supported(tnum) is None and supported(tspat) is None: + grouped.setdefault("GeneratedUdfs_portable_operator", []).append( + ' spark.udf().register("%s", (UDF2) (s1, s2) ->\n' + ' UdfMarshal.axisBool(s1, s2, GeneratedFunctions::%s, GeneratedFunctions::%s),\n' + ' DataTypes.BooleanType);' % (bare, tnum["name"], tspat["name"])) + naxis += 1 + cov += 1 + print(" dispatch bare names (space-axis) : %d" % naxis, file=sys.stderr) + + # ── NxN array (tgeoarr) pass: array-in + SETOF/array-of-struct UDFs ── + # The *_tgeoarr_tgeoarr kernels take Temporal** array args, so the 1:1 and @sqlfn + # passes exclude them (** -> internal). Emit each under its @sqlfn name via the array + # template: minDistance (array,array -> double) and the *Pairs (array,array[,dist] -> + # array>, consumed by LATERAL explode; MEOS 1-based -> 0-based). + narr = 0 + for f in fns: + s = f.get("sqlfn") + if not s or s in names: + continue + if jar_syms is not None and f["name"] not in jar_syms: + continue + shape = tgeoarr_shape(f) + if shape is None: + continue + grouped.setdefault(class_for(f.get("group")), []).append(emit_tgeoarr(s, f, shape)) + names.add(s) + cov += 1 + narr += 1 + print(" NxN array (tgeoarr) UDFs : %d" % narr, file=sys.stderr) + + # ── @sqlfn CANONICAL-NAME pass: emit the MobilityDB SQL surface ── + # Every catalog function carries the canonical MobilityDB SQL spelling in its + # @sqlfn tag (numInstants, eIntersects, atTime, asHexWKB ...). That is the name a + # user — and the portable BerlinMOD suite — actually calls, so emit each UDF under + # its @sqlfn name with the C symbol as backing. One @sqlfn often maps SEVERAL C + # overloads differing only by argument KIND (eIntersects <- eintersects_tgeo_tgeo / + # _tgeo_geo / _geo_tgeo); since Spark cannot overload a UDF name, those that share a + # marshalled _sig() are emitted as ONE arg-kind-dispatching UDF (emit_dispatch). + # Registered AFTER the contract bare names (class name sorts later) so an @sqlfn + # with full overload dispatch supersedes a single-backing portable registration. + # skip @sqlfn names already owned by the contract bare-name passes (operator + # superclass registrations). EXCLUDE the distance family: its names (tDistance / + # nearestApproachDistance) are better served by the @sqlfn arg-kind dispatch. + portable_names = {e["bareName"] for fn, fam in fams.items() if fn != "distance" for e in fam} + sqlgroups = {} + for f in fns: + s = f.get("sqlfn") + if not s or s in names or s in portable_names or supported(f) is not None: + continue + sqlgroups.setdefault(s, []).append(f) + nsql = nsqldisp = ndropped = nskip = 0 + sqlfn_emitted = set() + for sname in sorted(sqlgroups): + # time-restrict polymorphism (atTime / minusTime): the time arg type + # (timestamptz / tstzspan / tstzset / spanset) can't be ONE Spark UDF signature, + # so emit a String-classifying dispatch instead of the normal arg-kind one. + gnames = {f["name"] for f in sqlgroups[sname]} + trop = next((m for m in ("at", "minus") + if ("temporal_%s_timestamptz" % m) in gnames + and ("temporal_%s_tstzspan" % m) in gnames), None) + if trop: + grouped.setdefault("GeneratedUdfs_sqlfn", []).append(emit_timearg(sname, trop)) + sqlfn_emitted.add(sname) + nsql += 1 + cov += 1 + continue + # subgroup the overloads by marshalled signature; emit the largest consistent + # group (a name whose overloads disagree on arity/scalar-shape can't be one + # Spark UDF — take the dominant shape, the rest stay reachable via their C name). + bysig = {} + for f in sqlgroups[sname]: + sig = _sig(f) + if sig is not None: + bysig.setdefault(sig, []).append(f) + if not bysig: + continue + group = max(bysig.values(), key=len) + # A multi-overload @sqlfn needs a runtime parse dispatcher, which is only sound + # when every overload discriminates via hex-WKB / WKT — drop the text-*_in ones + # (stbox/tbox/cbuffer/npoint/pose), so e.g. nearestApproachDistance keeps just its + # tgeo_tgeo / tgeo_geo overloads. A name left with no safe overload is skipped + # (still reachable under its C names), never emitted as a fragile guess. + if len(group) > 1: + group = [f for f in group if _safe_dispatch(f)] + if not group: + nskip += 1 + continue + # Keep only parse-DISTINGUISHABLE overloads: one per _parsetuple, preferring the + # tgeo/geo family. Overloads differing only by temporal subtype can't be routed + # by parsing, so they're left to their C name (not silently mis-dispatched). + best = {} + for f in group: + t = _parsetuple(f) + if t not in best or _famrank(f) < _famrank(best[t]): + best[t] = f + disp = sorted(best.values(), key=lambda f: f["name"]) + ndropped += len(group) - len(disp) + # ever/always boolean predicates (eIntersects, aDisjoint, eDwithin ...) follow + # the MobilityDB @sqlfn convention and return int in C (1/0, -1 on + # error) but boolean in SQL. Tag them with a predicate sqlop so ret_emit yields + # BooleanType (== 1). Guarded on an int C-return, so atTime/asHexWKB (also a*) — + # which return a temporal / string — are untouched. + if re.match(r"[ea][A-Z]", sname): + disp = [dict(f, sqlop="?=") if norm(f["returnType"]["canonical"]) == "int" else f + for f in disp] + # expose the SQL-required arity (sqlArity) — default the optional trailing flags + # so e.g. asHexWKB(temporal) / trajectory(temporal) are 1-arg, matching SQL. + va = disp[0].get("sqlArity") + code = (emit_single(sname, disp[0], vis_arity=va) if len(disp) == 1 + else emit_dispatch(sname, disp, vis_arity=va)) + if len(disp) > 1: + nsqldisp += 1 + grouped.setdefault("GeneratedUdfs_sqlfn", []).append(code) + sqlfn_emitted.add(sname) + nsql += 1 + cov += 1 + print(" @sqlfn canonical names : %d (%d arg-kind-dispatched, %d subtype-siblings + %d unsafe-overload names to C-name)" % + (nsql, nsqldisp, ndropped, nskip), file=sys.stderr) + + # Organize by doxygen module group (@ingroup), one class per group — the SAME + # structure as the MEOS reference manual / XML docs, so a function is found in the + # same place across tools. This also keeps every class small, dodging the per-class + # constant-pool / BootstrapMethods limits a single 2300-lambda class would hit. + # Within a class, register() statements are chunked to stay under the 64 KB method + # bytecode limit. + os.makedirs(args.out, exist_ok=True) + # Clean stale generated files first: this tool fully OWNS args.out, so a prior + # run's classes (a function later excluded by the jar arity/kind cross-check, or a + # now-empty/renamed group) must not linger — they would silently break the build. + for _old in glob.glob(os.path.join(args.out, "*.java")): + os.remove(_old) + CHUNK = 40 # register() statements per method (64 KB method-bytecode safety) + MAXCLASS = 120 # UDFs per class (constant-pool / BootstrapMethods safety) + written = [] + for grp in sorted(grouped): + part = grouped[grp] + subs = [part[i:i + MAXCLASS] for i in range(0, len(part), MAXCLASS)] + for si, sub in enumerate(subs): + cls = grp if len(subs) == 1 else "%s_%d" % (grp, si) + chunks = [sub[i:i + CHUNK] for i in range(0, len(sub), CHUNK)] + body = GEN_NOTE + IMPORTS + "\nfinal class %s {\n private %s() {}\n" % (cls, cls) + for i, ch in enumerate(chunks): + body += "\n private static void reg%d(SparkSession spark) {\n" % i + "\n".join(ch) + "\n }\n" + body += "\n static void register(SparkSession spark) {\n" + body += "\n".join(" reg%d(spark);" % i for i in range(len(chunks))) + body += "\n }\n}\n" + with open(os.path.join(args.out, cls + ".java"), "w") as fh: + fh.write(body) + written.append(cls) + + # Build the WKB-kind byte sets from the catalog's MeosType enum (the WKB type byte = + # the enum value): categorise each T_* by name suffix so the safe hex parsers know + # which MeosType bytes belong to temporals vs spans vs spansets vs sets. + mt = next((e for e in cat.get("enums", []) if e["name"] in ("MeosType", "meosType")), None) + kinds = {"TEMPORAL_WKB": [], "SPAN_WKB": [], "SPANSET_WKB": [], "SET_WKB": []} + for v in (mt.get("values") or mt.get("members") or []) if mt else []: + nm = v["name"] if isinstance(v, dict) else v + val = v.get("value") if isinstance(v, dict) else None + if val is None or not nm: + continue + if nm.endswith("SPANSET"): + kinds["SPANSET_WKB"].append(val) + elif nm.endswith("SPAN"): + kinds["SPAN_WKB"].append(val) + elif nm.endswith("SET"): + kinds["SET_WKB"].append(val) + elif nm.startswith("T_T") and "BOX" not in nm: + kinds["TEMPORAL_WKB"].append(val) + wkb_lines = "\n".join( + " private static final java.util.Set %s = java.util.Set.of(%s);" + % (k, ", ".join(str(x) for x in sorted(set(v)))) for k, v in kinds.items()) + with open(os.path.join(args.out, "UdfMarshal.java"), "w") as fh: + fh.write(MARSHAL.replace("__WKB_KINDS__", wkb_lines)) + + main_cls = GEN_NOTE + IMPORTS + "\npublic final class GeneratedSpatioTemporalUDFs {\n" + main_cls += " private GeneratedSpatioTemporalUDFs() {}\n" + main_cls += "\n public static void registerAll(SparkSession spark) {\n" + main_cls += "\n".join(" %s.register(spark);" % c for c in written) + main_cls += "\n }\n}\n" + with open(os.path.join(args.out, "GeneratedSpatioTemporalUDFs.java"), "w") as fh: + fh.write(main_cls) + + # ── per-thread MEOS-init invariant (build-failing) ──────────────────────────── + # MEOS keeps locale/collation, session timezone, PROJ context and RNGs in THREAD- + # LOCAL storage, so every thread (Spark executor threads run UDFs off the thread + # that called meos_initialize()) must run the per-thread init guard before its first + # MEOS call — exactly the gap that crashed MobilityDuck's table functions. Assert it + # for EVERY emitted entry point so a future emit path can't silently drop the guard + # as the bindings are regenerated (the codegen north-star). A register() lambda is + # guarded iff ensureReady() / axisBool / restrictTime (the latter two call + # ensureReady() first) appears before the first GeneratedFunctions call in its body. + unguarded = [] + for fp in glob.glob(os.path.join(args.out, "*.java")): + src = open(fp).read() + for m in re.finditer(r'udf\(\)\.register\("([^"]+)"', src): + body = src[m.start():m.start() + 1600] + gf = body.find("GeneratedFunctions.") + guard = min([x for x in (body.find("ensureReady"), body.find("axisBool"), + body.find("restrictTime")) if x >= 0] or [1 << 30]) + if gf >= 0 and guard > gf: + unguarded.append("%s (%s)" % (m.group(1), os.path.basename(fp))) + if unguarded: + print("FATAL: %d generated UDF entry point(s) reach MEOS without a per-thread " + "init guard (MeosThread.ensureReady):" % len(unguarded), file=sys.stderr) + for u in unguarded[:20]: + print(" " + u, file=sys.stderr) + sys.exit(1) + + print("wrote %d group classes + UdfMarshal + GeneratedSpatioTemporalUDFs in %s" % (len(written), args.out), file=sys.stderr) + print(" per-thread MEOS-init guard : every entry point verified", file=sys.stderr) + print(" JMEOS functions in catalog : %d" % total, file=sys.stderr) + print(" 1:1 UDFs emitted (reached) : %d (%.0f%%)" % (cov, 100.0*cov/total), file=sys.stderr) + print(" internal (excluded) : %d" % internal, file=sys.stderr) + print(" deferred type gaps (top):", file=sys.stderr) + for k, c in skips.most_common(18): + print(" %4d %s" % (c, k), file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/tools/meos-idl.json b/tools/meos-idl.json new file mode 100644 index 00000000..b3cd2f12 --- /dev/null +++ b/tools/meos-idl.json @@ -0,0 +1,111324 @@ +{ + "functions": [ + { + "name": "meos_error", + "file": "meos_error.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "errlevel", + "cType": "int", + "canonical": "int" + }, + { + "name": "errcode", + "cType": "int", + "canonical": "int" + }, + { + "name": "format", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "meos_errno", + "file": "meos_error.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [] + }, + { + "name": "meos_errno_set", + "file": "meos_error.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "err", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "meos_errno_restore", + "file": "meos_error.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "err", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "meos_errno_reset", + "file": "meos_error.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [] + }, + { + "name": "meos_array_create", + "file": "meos.h", + "returnType": { + "c": "MeosArray *", + "canonical": "struct MeosArray *" + }, + "params": [ + { + "name": "elem_size", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_add", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + }, + { + "name": "value", + "cType": "void *", + "canonical": "void *" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_get", + "file": "meos.h", + "returnType": { + "c": "void *", + "canonical": "void *" + }, + "params": [ + { + "name": "array", + "cType": "const MeosArray *", + "canonical": "const struct MeosArray *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_count", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "array", + "cType": "const MeosArray *", + "canonical": "const struct MeosArray *" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_reset", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_reset_free", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_destroy", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_misc" + }, + { + "name": "meos_array_destroy_free", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_misc" + }, + { + "name": "rtree_create_intspan", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_bigintspan", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_floatspan", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_datespan", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_tstzspan", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_tbox", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_create_stbox", + "file": "meos.h", + "returnType": { + "c": "RTree *", + "canonical": "struct RTree *" + }, + "params": [] + }, + { + "name": "rtree_free", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rtree", + "cType": "RTree *", + "canonical": "struct RTree *" + } + ], + "group": "meos_temporal_box_index" + }, + { + "name": "rtree_insert", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rtree", + "cType": "RTree *", + "canonical": "struct RTree *" + }, + { + "name": "box", + "cType": "void *", + "canonical": "void *" + }, + { + "name": "id", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_box_index" + }, + { + "name": "rtree_insert_temporal", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rtree", + "cType": "RTree *", + "canonical": "struct RTree *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "id", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_box_index" + }, + { + "name": "rtree_insert_temporal_split", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rtree", + "cType": "RTree *", + "canonical": "struct RTree *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "id", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxboxes", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_box_index" + }, + { + "name": "rtree_search", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "rtree", + "cType": "const RTree *", + "canonical": "const struct RTree *" + }, + { + "name": "op", + "cType": "RTreeSearchOp", + "canonical": "RTreeSearchOp" + }, + { + "name": "query", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "result", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_geo_box_index" + }, + { + "name": "rtree_search_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "rtree", + "cType": "const RTree *", + "canonical": "const struct RTree *" + }, + { + "name": "op", + "cType": "RTreeSearchOp", + "canonical": "RTreeSearchOp" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_temporal_box_index" + }, + { + "name": "rtree_search_temporal_dedup", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "rtree", + "cType": "const RTree *", + "canonical": "const struct RTree *" + }, + { + "name": "op", + "cType": "RTreeSearchOp", + "canonical": "RTreeSearchOp" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxboxes", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "MeosArray *", + "canonical": "struct MeosArray *" + } + ], + "group": "meos_temporal_box_index" + }, + { + "name": "meos_initialize_error_handler", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "err_handler", + "cType": "error_handler_fn", + "canonical": "void (*)(int, int, const char *)" + } + ] + }, + { + "name": "meos_initialize_noexit_error_handler", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_initialize_timezone", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "name", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "meos_initialize_collation", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_finalize_timezone", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_finalize_collation", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_finalize_projsrs", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_finalize_ways", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_set_datestyle", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "newval", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "extra", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "meos_set_intervalstyle", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "newval", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "extra", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "meos_get_datestyle", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [] + }, + { + "name": "meos_get_intervalstyle", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [] + }, + { + "name": "meos_set_spatial_ref_sys_csv", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "path", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "meos_set_ways_csv", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "path", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_setup" + }, + { + "name": "meos_initialize", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "meos_finalize", + "file": "meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "bigintset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintspan_expand", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Numspan_expand", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "bigintspan_in", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_in", + "sqlfn": "span_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintspan_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_out", + "sqlfn": "span_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintspanset_in", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_in", + "sqlfn": "spanset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintspanset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "dateset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "dateset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "datespan_in", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_in", + "sqlfn": "span_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "datespan_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_out", + "sqlfn": "span_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "datespanset_in", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_in", + "sqlfn": "spanset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "datespanset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatspan_expand", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Numspan_expand", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_in", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_in", + "sqlfn": "span_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatspan_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Span_out", + "sqlfn": "span_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatspanset_in", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_in", + "sqlfn": "spanset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "floatspanset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intspan_expand", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Numspan_expand", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "intspan_in", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_in", + "sqlfn": "span_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intspan_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_out", + "sqlfn": "span_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intspanset_in", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_in", + "sqlfn": "spanset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "intspanset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "set_as_hexwkb", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Set_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_inout" + }, + { + "name": "set_as_wkb", + "file": "meos.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Set_send", + "sqlfn": "intset_send", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "set_from_hexwkb", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_from_hexwkb", + "sqlfn": "intsetFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "set_from_wkb", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Set_recv", + "sqlfn": "intset_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "span_as_hexwkb", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Span_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_inout" + }, + { + "name": "span_as_wkb", + "file": "meos.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Span_send", + "sqlfn": "span_send", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "span_from_hexwkb", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_from_hexwkb", + "sqlfn": "intspanFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "span_from_wkb", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Span_recv", + "sqlfn": "span_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "spanset_as_hexwkb", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Spanset_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_inout" + }, + { + "name": "spanset_as_wkb", + "file": "meos.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Spanset_send", + "sqlfn": "spanset_send", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "spanset_from_hexwkb", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_from_hexwkb", + "sqlfn": "intspansetFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "spanset_from_wkb", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Spanset_recv", + "sqlfn": "spanset_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "textset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "textset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzset_in", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzspan_in", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Span_in", + "sqlfn": "span_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzspan_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_out", + "sqlfn": "span_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzspanset_in", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Spanset_in", + "sqlfn": "spanset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "tstzspanset_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_inout" + }, + { + "name": "bigintset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const int64_t *", + "canonical": "const int64_t *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "bigintspan_make", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "upper", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Span_constructor", + "sqlfn": "intspan", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_setspan_constructor" + }, + { + "name": "dateset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const DateADT *", + "canonical": "const DateADT *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "datespan_make", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "upper", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Span_constructor", + "sqlfn": "intspan", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_setspan_constructor" + }, + { + "name": "floatset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const double *", + "canonical": "const double *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "floatspan_make", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "double", + "canonical": "double" + }, + { + "name": "upper", + "cType": "double", + "canonical": "double" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Span_constructor", + "sqlfn": "intspan", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_setspan_constructor" + }, + { + "name": "intset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "intspan_make", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "int", + "canonical": "int" + }, + { + "name": "upper", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Span_constructor", + "sqlfn": "intspan", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_setspan_constructor" + }, + { + "name": "set_copy", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_setspan_constructor" + }, + { + "name": "span_copy", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_constructor" + }, + { + "name": "spanset_copy", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_setspan_constructor" + }, + { + "name": "spanset_make", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "spans", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spanset_constructor", + "sqlfn": "spanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "textset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "tstzset_make", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const TimestampTz *", + "canonical": "const TimestampTz *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_constructor" + }, + { + "name": "tstzspan_make", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Span_constructor", + "sqlfn": "intspan", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_setspan_constructor" + }, + { + "name": "bigint_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "bigint_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Value_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "bigint_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Value_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "bigintspan_to_intspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "bigintspan_to_floatspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "date_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "date_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Value_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "date_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Value_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "dateset_to_tstzset", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Dateset_to_tstzset", + "sqlfn": "tstzset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "datespan_to_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "datespanset_to_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Datespanset_to_tstzspanset", + "sqlfn": "tstzspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "float_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "float_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Value_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "float_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Value_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "floatset_to_intset", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Floatset_to_intset", + "sqlfn": "intset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "floatspan_to_bigintspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "floatspan_to_intspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "floatspanset_to_intspanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Floatspanset_to_intspanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "int_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "int_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Value_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "int_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Value_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "intset_to_floatset", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Intset_to_floatset", + "sqlfn": "floatset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "intspan_to_bigintspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "intspan_to_floatspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "intspanset_to_floatspanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Intspanset_to_floatspanset", + "sqlfn": "floatspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "set_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "set_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "span_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Spanset_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "text_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "timestamptz_to_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "timestamptz_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Value_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "timestamptz_to_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Value_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_conversion" + }, + { + "name": "tstzset_to_dateset", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tstzset_to_dateset", + "sqlfn": "dateset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "tstzspan_to_datespan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "tstzspanset_to_datespanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_to_datespanset", + "sqlfn": "datespanset", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_setspan_conversion" + }, + { + "name": "bigintset_end_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintset_start_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "int64_t *", + "canonical": "int64_t *" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintset_values", + "file": "meos.h", + "returnType": { + "c": "int64_t *", + "canonical": "int64_t *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspan_lower", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspan_upper", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspan_width", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Numspan_width", + "sqlfn": "width", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspanset_lower", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspanset_upper", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintspanset_width", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_setspan_accessor" + }, + { + "name": "dateset_end_value", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "dateset_start_value", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "dateset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "DateADT *", + "canonical": "DateADT *" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "dateset_values", + "file": "meos.h", + "returnType": { + "c": "DateADT *", + "canonical": "DateADT *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespan_duration", + "file": "meos.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Datespan_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespan_lower", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespan_upper", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_date_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "DateADT *", + "canonical": "DateADT *" + } + ], + "mdbC": "Datespanset_date_n", + "sqlfn": "dateN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_dates", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Datespanset_dates", + "sqlfn": "dates", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_duration", + "file": "meos.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Datespanset_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_end_date", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Datespanset_end_date", + "sqlfn": "endDate", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_num_dates", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Datespanset_num_dates", + "sqlfn": "numDates", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "datespanset_start_date", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Datespanset_start_date", + "sqlfn": "startDate", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatset_end_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatset_start_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "floatset_values", + "file": "meos.h", + "returnType": { + "c": "double *", + "canonical": "double *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspan_lower", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspan_upper", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspan_width", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Numspan_width", + "sqlfn": "width", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspanset_lower", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspanset_upper", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "floatspanset_width", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_setspan_accessor" + }, + { + "name": "intset_end_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intset_start_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "intset_values", + "file": "meos.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspan_lower", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspan_upper", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspan_width", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Numspan_width", + "sqlfn": "width", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspanset_lower", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspanset_upper", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "intspanset_width", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_setspan_accessor" + }, + { + "name": "set_hash", + "file": "meos.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_hash", + "sqlfn": "hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "set_hash_extended", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_hash_extended", + "sqlfn": "hash_extended", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "set_num_values", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_num_values", + "sqlfn": "numValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "span_hash", + "file": "meos.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_hash", + "sqlfn": "span_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "span_hash_extended", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Span_hash_extended", + "sqlfn": "hash_extended", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "span_lower_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower_inc", + "sqlfn": "lower_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "span_upper_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower_inc", + "sqlfn": "lower_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_end_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_end_span", + "sqlfn": "endSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_hash", + "file": "meos.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_hash", + "sqlfn": "spanset_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_hash_extended", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spanset_hash_extended", + "sqlfn": "spanset_hash_extended", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_lower_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower_inc", + "sqlfn": "lower_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_num_spans", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_num_spans", + "sqlfn": "numSpans", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_span_n", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spanset_span_n", + "sqlfn": "spanN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_spanarr", + "file": "meos.h", + "returnType": { + "c": "Span **", + "canonical": "struct Span **" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_start_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_start_span", + "sqlfn": "startSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "spanset_upper_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper_inc", + "sqlfn": "lower_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "textset_end_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "textset_start_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "textset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "text **", + "canonical": "text **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "textset_values", + "file": "meos.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzset_end_value", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzset_start_value", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzset_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzset_values", + "file": "meos.h", + "returnType": { + "c": "TimestampTz *", + "canonical": "TimestampTz *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspan_duration", + "file": "meos.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tstzspan_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspan_lower", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspan_upper", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_duration", + "file": "meos.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tstzspanset_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_end_timestamptz", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_end_timestamptz", + "sqlfn": "endTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_lower", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_num_timestamps", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_num_timestamps", + "sqlfn": "numTimestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_start_timestamptz", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_start_timestamptz", + "sqlfn": "startTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_timestamps", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_timestamps", + "sqlfn": "timestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_timestamptz_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Tstzspanset_timestamptz_n", + "sqlfn": "timestampN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_accessor" + }, + { + "name": "tstzspanset_upper", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_accessor" + }, + { + "name": "bigintset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "bigintspan_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspan_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "bigintspanset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "dateset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "datespan_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspan_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "datespanset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "float_round", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_base_types" + }, + { + "name": "floatset_ceil", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Floatset_ceil", + "sqlfn": "ceil", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatset_degrees", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Floatset_degrees", + "sqlfn": "degrees", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatset_floor", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Floatset_floor", + "sqlfn": "floor", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatset_radians", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Floatset_radians", + "sqlfn": "radians", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_ceil", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Floatspan_ceil", + "sqlfn": "ceil", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_degrees", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Floatspan_degrees", + "sqlfn": "degrees", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_floor", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Floatspan_floor", + "sqlfn": "floor", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_radians", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Floatspan_radians", + "sqlfn": "radians", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_round", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "floatspan_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspan_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_ceil", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Floatspanset_ceil", + "sqlfn": "ceil", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_floor", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Floatspanset_floor", + "sqlfn": "floor", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_degrees", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Floatspanset_degrees", + "sqlfn": "degrees", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_radians", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Floatspanset_radians", + "sqlfn": "radians", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_round", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Floatspanset_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "floatspanset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "intset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "intspan_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspan_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "intspanset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "tstzspan_expand", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tstzspan_expand", + "sqlfn": "expand", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "set_round", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "textcat_text_textset", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Textcat_text_textset", + "sqlfn": "setConcat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_setspan_transf" + }, + { + "name": "textcat_textset_text", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Textcat_textset_text", + "sqlfn": "setConcat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_setspan_transf" + }, + { + "name": "textset_initcap", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Textset_initcap", + "sqlfn": "initcap", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "textset_lower", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Textset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "textset_upper", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Textset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_transf" + }, + { + "name": "timestamptz_tprecision", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "tstzset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tstzset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "tstzset_tprecision", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "tstzspan_shift_scale", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tstzspan_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "tstzspan_tprecision", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "tstzspanset_shift_scale", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_transf" + }, + { + "name": "tstzspanset_tprecision", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_transf" + }, + { + "name": "set_cmp", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_cmp", + "sqlfn": "set_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_comp" + }, + { + "name": "set_eq", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_eq", + "sqlfn": "set_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_setspan_comp" + }, + { + "name": "set_ge", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_ge", + "sqlfn": "set_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_setspan_comp" + }, + { + "name": "set_gt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_gt", + "sqlfn": "set_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_setspan_comp" + }, + { + "name": "set_le", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_le", + "sqlfn": "set_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_setspan_comp" + }, + { + "name": "set_lt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_lt", + "sqlfn": "set_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_setspan_comp" + }, + { + "name": "set_ne", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_ne", + "sqlfn": "set_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_setspan_comp" + }, + { + "name": "span_cmp", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_cmp", + "sqlfn": "span_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_comp" + }, + { + "name": "span_eq", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_eq", + "sqlfn": "span_eq", + "sqlArity": 2, + "sqlArityMax": 5, + "sqlop": "=", + "group": "meos_setspan_comp" + }, + { + "name": "span_ge", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_gt", + "sqlfn": "span_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_setspan_comp" + }, + { + "name": "span_gt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_ge", + "sqlfn": "span_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_setspan_comp" + }, + { + "name": "span_le", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_le", + "sqlfn": "span_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_setspan_comp" + }, + { + "name": "span_lt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_lt", + "sqlfn": "span_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_setspan_comp" + }, + { + "name": "span_ne", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_ne", + "sqlfn": "span_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_cmp", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_cmp", + "sqlfn": "spanset_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_comp" + }, + { + "name": "spanset_eq", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_eq", + "sqlfn": "spanset_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_ge", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_ge", + "sqlfn": "spanset_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_gt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_gt", + "sqlfn": "spanset_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_le", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_le", + "sqlfn": "spanset_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_lt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lt", + "sqlfn": "spanset_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_setspan_comp" + }, + { + "name": "spanset_ne", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_ne", + "sqlfn": "spanset_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_setspan_comp" + }, + { + "name": "set_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_spans", + "sqlfn": "spans", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_bbox_split" + }, + { + "name": "set_split_each_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "elems_per_span", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_split_each_n_spans", + "sqlfn": "splitEachNSpans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_bbox_split" + }, + { + "name": "set_split_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "span_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_split_n_spans", + "sqlfn": "splitNspans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_bbox_split" + }, + { + "name": "spanset_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Spanset_spans", + "sqlfn": "spans", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_bbox_split" + }, + { + "name": "spanset_split_each_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "elems_per_span", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Spanset_split_each_n_spans", + "sqlfn": "splitEachNspans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_bbox_split" + }, + { + "name": "spanset_split_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "span_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Spanset_split_n_spans", + "sqlfn": "splitNspans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_bbox_split" + }, + { + "name": "adjacent_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Adjacent_span_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Adjacent_span_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adjacent_span_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Adjacent_span_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Adjacent_span_span", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Adjacent_span_spanset", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Adjacent_span_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Adjacent_spanset_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Adjacent_spanset_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adjacent_spanset_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Adjacent_spanset_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Adjacent_spanset_value", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Adjacent_spanset_span", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "adjacent_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Adjacent_spanset_spanset", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_setspan_topo" + }, + { + "name": "contained_bigint_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_bigint_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_value_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_date_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_date_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_date_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_value_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_float_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_float_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_float_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_value_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_int_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_int_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_int_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_value_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_set_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_span_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_spanset_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_spanset_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_text_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_value_span", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contained_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contained_value_spanset", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contains_set_set", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_text", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Contains_span_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Contains_span_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Contains_span_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Contains_span_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contains_span_span", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contains_span_spanset", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Contains_span_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Contains_spanset_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Contains_spanset_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Contains_spanset_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Contains_spanset_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contains_spanset_span", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Contains_spanset_spanset", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "contains_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Contains_spanset_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_setspan_topo" + }, + { + "name": "overlaps_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overlaps_set_set", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_setspan_topo" + }, + { + "name": "overlaps_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overlaps_span_span", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_setspan_topo" + }, + { + "name": "overlaps_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overlaps_span_spanset", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_setspan_topo" + }, + { + "name": "overlaps_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overlaps_spanset_span", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_setspan_topo" + }, + { + "name": "overlaps_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overlaps_spanset_spanset", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_setspan_topo" + }, + { + "name": "after_date_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_date_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_value_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_date_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_value_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_set_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Right_span_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Right_span_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Right_spanset_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Right_spanset_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_value_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "after_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_value_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "before_date_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_date_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_value_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_date_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_value_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_set_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Left_span_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Left_span_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Left_spanset_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Left_spanset_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_value_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "before_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_value_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_bigint_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_bigint_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_value_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_value_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_float_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_float_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_value_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_float_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_value_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_int_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_int_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_value_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_int_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_value_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_set_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_set_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_set_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_set_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_set_text", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Left_set_value", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Left_span_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Left_span_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Left_span_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_span_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_span_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Left_spanset_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Left_spanset_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Left_spanset_value", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_spanset_span", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Left_spanset_spanset", + "sqlfn": "span_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "left_text_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Left_value_set", + "sqlfn": "set_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_date_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "overafter_date_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_value_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_date_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_value_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_set_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overright_span_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overright_span_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overright_spanset_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overright_spanset_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "overafter_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_value_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overafter_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_value_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_date_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_date_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_value_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_date_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_value_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_set_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_span_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overleft_span_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overleft_span_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_spanset_date", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Overleft_spanset_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Overleft_spanset_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_value_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overbefore_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_value_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_bigint_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_bigint_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_value_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_value_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_float_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_float_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_value_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_float_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_value_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_int_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_int_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_value_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_int_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_value_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_set_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_set_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_set_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_set_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_set_text", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Overleft_set_value", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overleft_span_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overleft_span_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overleft_span_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_span_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_span_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overleft_spanset_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overleft_spanset_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overleft_spanset_value", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_spanset_span", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overleft_spanset_spanset", + "sqlfn": "span_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overleft_text_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overleft_value_set", + "sqlfn": "set_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_setspan_pos" + }, + { + "name": "overright_bigint_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "overright_bigint_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_value_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_value_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_float_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "overright_float_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_value_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_float_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_value_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_int_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "overright_int_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_value_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_int_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_value_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_set_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_set_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_set_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_set_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_set_text", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Overright_set_value", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overright_span_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overright_span_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overright_span_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_span_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_span_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Overright_spanset_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Overright_spanset_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Overright_spanset_value", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_spanset_span", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Overright_spanset_spanset", + "sqlfn": "span_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_setspan_pos" + }, + { + "name": "overright_text_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Overright_value_set", + "sqlfn": "set_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_pos" + }, + { + "name": "right_bigint_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_bigint_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_value_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_value_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_float_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_float_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_value_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_float_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_value_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_int_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_int_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_value_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_int_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_value_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_set_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_set_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_set_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_set_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_set_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_set_text", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Right_set_value", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_span_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Right_span_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_span_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Right_span_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_span_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Right_span_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_span_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_span_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_span_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_span_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Right_spanset_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_spanset_float", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Right_spanset_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_spanset_int", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Right_spanset_value", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_spanset_span", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_spanset_span", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Right_spanset_spanset", + "sqlfn": "span_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "right_text_set", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Right_value_set", + "sqlfn": "set_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_setspan_pos" + }, + { + "name": "intersection_bigint_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "intersection_date_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "intersection_float_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "intersection_int_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_bigint", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_date", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_float", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_int", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Intersection_set_set", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_text", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_bigint", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Intersection_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_date", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Intersection_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_float", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Intersection_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_int", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Intersection_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Intersection_span_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Intersection_span_spanset", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Intersection_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Intersection_spanset_value", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_date", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Intersection_spanset_value", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_float", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Intersection_spanset_value", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_int", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Intersection_spanset_value", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Intersection_spanset_span", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Intersection_spanset_spanset", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Intersection_spanset_value", + "sqlfn": "spansetIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "intersection_text_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "intersection_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "minus_bigint_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_bigint_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_value_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_value_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_date_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_date_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_value_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_date_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_value_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_float_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_float_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_value_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_float_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_value_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_int_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_int_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_value_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_int_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_value_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_bigint", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_date", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_float", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_int", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_set_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_text", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_bigint", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Minus_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_date", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Minus_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_float", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Minus_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_int", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Minus_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_span_span", + "sqlfn": "time_minus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_span_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Minus_span_value", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Minus_spanset_value", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_date", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Minus_spanset_value", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_float", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Minus_spanset_value", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_int", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Minus_spanset_value", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_spanset_span", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_spanset_spanset", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Minus_spanset_value", + "sqlfn": "spansetMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_text_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "minus_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Minus_value_span", + "sqlfn": "spanIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_setspan_set" + }, + { + "name": "minus_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Minus_value_spanset", + "sqlfn": "spanMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_setspan_set" + }, + { + "name": "union_bigint_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_bigint_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Union_value_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_bigint_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_date_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_date_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Union_value_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_date_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "ss", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_float_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_float_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Union_value_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_float_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_int_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_int_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Union_value_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_int_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_bigint", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_date", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_float", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_int", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_set", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_text", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_bigint", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Union_span_value", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_date", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Union_span_value", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_float", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Union_span_value", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_int", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Union_span_value", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Union_span_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "super_union_span_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_span_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Union_span_spanset", + "sqlfn": "spanUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Union_span_value", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_date", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_float", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_int", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Union_spanset_span", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Union_spanset_spanset", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_text_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_timestamptz_set", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_timestamptz_span", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Union_value_span", + "sqlfn": "time_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "union_timestamptz_spanset", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "ss", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "mdbC": "Union_spanset_value", + "sqlfn": "spansetUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_setspan_set" + }, + { + "name": "distance_bigintset_bigintset", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_bigintspan_bigintspan", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_bigintspanset_bigintspan", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_bigintspanset_bigintspanset", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_spanset", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_dateset_dateset", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_datespan_datespan", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_datespanset_datespan", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_datespanset_datespanset", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_spanset", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_floatset_floatset", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_floatspan_floatspan", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_floatspanset_floatspan", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_floatspanset_floatspanset", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_spanset", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_intset_intset", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_intspan_intspan", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_intspanset_intspan", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_intspanset_intspanset", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_spanset", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_set_bigint", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Distance_set_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_set_date", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Distance_set_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_set_float", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Distance_set_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_set_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Distance_set_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_set_timestamptz", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Distance_set_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_span_bigint", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Distance_span_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_span_date", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Distance_span_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_span_float", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Distance_span_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_span_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Distance_span_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_span_timestamptz", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Distance_span_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_spanset_bigint", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Distance_spanset_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_spanset_date", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "mdbC": "Distance_spanset_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_spanset_float", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Distance_spanset_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_spanset_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Distance_spanset_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_spanset_timestamptz", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Distance_spanset_value", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_tstzset_tstzset", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_tstzspan_tstzspan", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_tstzspanset_tstzspan", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "distance_tstzspanset_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_spanset", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_setspan_dist" + }, + { + "name": "bigint_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "bigint_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "date_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "date_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "float_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "float_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "int_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "int_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "i", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "set_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_agg" + }, + { + "name": "set_union_finalfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + } + ], + "mdbC": "Set_union_finalfn", + "sqlfn": "union", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_setspan_agg" + }, + { + "name": "set_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "s", + "cType": "Set *", + "canonical": "Set *" + } + ], + "mdbC": "Set_union_transfn", + "sqlfn": "union", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_agg" + }, + { + "name": "span_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_agg" + }, + { + "name": "span_union_transfn", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "state", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "spanset_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_agg" + }, + { + "name": "spanset_union_finalfn", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "state", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "spanset_union_transfn", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "state", + "cType": "SpanSet *", + "canonical": "struct SpanSet *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_union_transfn", + "sqlfn": "union", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_setspan_agg" + }, + { + "name": "text_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "timestamptz_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "timestamptz_union_transfn", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_agg" + }, + { + "name": "bigint_get_bin", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "value", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "vsize", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "vorigin", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "bigintspan_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "vsize", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "vorigin", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "bigintspanset_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "vsize", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "vorigin", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "date_get_bin", + "file": "meos.h", + "returnType": { + "c": "DateADT", + "canonical": "DateADT" + }, + "params": [ + { + "name": "d", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "DateADT", + "canonical": "DateADT" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "datespan_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "datespanset_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "DateADT", + "canonical": "DateADT" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "float_get_bin", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "value", + "cType": "double", + "canonical": "double" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "floatspan_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "floatspanset_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "int_get_bin", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "int", + "canonical": "int" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "intspan_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "intspanset_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "timestamptz_get_bin", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "tstzspan_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "origin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "tstzspanset_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_setspan_bin" + }, + { + "name": "tbox_as_hexwkb", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Tbox_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_box_inout" + }, + { + "name": "tbox_as_wkb", + "file": "meos.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Tbox_send", + "sqlfn": "tbox_send", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_inout" + }, + { + "name": "tbox_from_hexwkb", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Tbox_from_hexwkb", + "sqlfn": "tboxFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_inout" + }, + { + "name": "tbox_from_wkb", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Tbox_recv", + "sqlfn": "tbox_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_inout" + }, + { + "name": "tbox_in", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Tbox_in", + "sqlfn": "tbox_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_inout" + }, + { + "name": "tbox_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tbox_out", + "sqlfn": "tbox_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_inout" + }, + { + "name": "float_timestamptz_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Number_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "float_tstzspan_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Number_tstzspan_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "int_timestamptz_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Number_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "bigint_timestamptz_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Number_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "int_tstzspan_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Number_tstzspan_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "bigint_tstzspan_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Number_tstzspan_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "numspan_tstzspan_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "p", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Numspan_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "numspan_timestamptz_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Numspan_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_constructor" + }, + { + "name": "tbox_copy", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "group": "meos_box_constructor" + }, + { + "name": "tbox_make", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "sp1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "sp2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_box_constructor" + }, + { + "name": "float_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Number_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "int_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Number_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "bigint_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Number_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "set_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "span_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "spanset_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "tbox_to_bigintspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_bigintspan", + "sqlfn": "bigintspan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "tbox_to_intspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_intspan", + "sqlfn": "floatspan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "tbox_to_floatspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_floatspan", + "sqlfn": "floatspan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "tbox_to_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_tstzspan", + "sqlfn": "timeSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "timestamptz_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_conversion" + }, + { + "name": "tbox_hash", + "file": "meos.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_hash", + "sqlfn": "tbox_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_hash_extended", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tbox_hash_extended", + "sqlfn": "tbox_hash_extended", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_accessor" + }, + { + "name": "tbox_hast", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_hast", + "sqlfn": "hasT", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_hasx", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_hasx", + "sqlfn": "hasX", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_tmax", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Tbox_tmax", + "sqlfn": "Tmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_tmax_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Tbox_tmax_inc", + "sqlfn": "Tmin_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_tmin", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Tbox_tmin", + "sqlfn": "Tmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_tmin_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Tbox_tmin_inc", + "sqlfn": "Tmin_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_xmax", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tbox_xmax", + "sqlfn": "Xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_accessor" + }, + { + "name": "tbox_xmax_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Tbox_xmax_inc", + "sqlfn": "Xmin_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbox_xmin", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tbox_xmin", + "sqlfn": "Xmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_accessor" + }, + { + "name": "tbox_xmin_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Tbox_xmin_inc", + "sqlfn": "Xmin_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxfloat_xmax", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tbox_xmax", + "sqlfn": "Xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxfloat_xmin", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tbox_xmin", + "sqlfn": "Xmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxint_xmax", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_xmax", + "sqlfn": "Xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxbigint_xmax", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "int64_t *", + "canonical": "int64_t *" + } + ], + "mdbC": "Tbox_xmax", + "sqlfn": "Xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxint_xmin", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_xmin", + "sqlfn": "Xmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tboxbigint_xmin", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "int64_t *", + "canonical": "int64_t *" + } + ], + "mdbC": "Tbox_xmin", + "sqlfn": "Xmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_box_accessor" + }, + { + "name": "tbigintbox_expand", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Tbox_expand_value", + "sqlfn": "expandValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tbigintbox_shift_scale", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tbox_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tbox_expand_time", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tbox_expand_time", + "sqlfn": "expandTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tbox_round", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tbox_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tfloatbox_shift_scale", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tbox_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tintbox_shift_scale", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tbox_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tbox_shift_scale_time", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tbox_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tfloatbox_expand", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tbox_expand_value", + "sqlfn": "expandValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "tintbox_expand", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tbox_expand_value", + "sqlfn": "expandValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_transf" + }, + { + "name": "union_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Union_tbox_tbox", + "sqlfn": "union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_box_set" + }, + { + "name": "intersection_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Intersection_tbox_tbox", + "sqlfn": "intersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_box_set" + }, + { + "name": "adjacent_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Adjacent_tbox_tbox", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_box_bbox_topo" + }, + { + "name": "contained_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Contained_tbox_tbox", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_box_bbox_topo" + }, + { + "name": "contains_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Contains_tbox_tbox", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "@>", + "group": "meos_box_bbox_topo" + }, + { + "name": "overlaps_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overlaps_tbox_tbox", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_box_bbox_topo" + }, + { + "name": "same_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Same_tbox_tbox", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_box_bbox_topo" + }, + { + "name": "after_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "After_tbox_tbox", + "sqlfn": "tbox_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_box_bbox_pos" + }, + { + "name": "before_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Before_tbox_tbox", + "sqlfn": "tbox_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_box_bbox_pos" + }, + { + "name": "left_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Left_tbox_tbox", + "sqlfn": "tbox_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_box_bbox_pos" + }, + { + "name": "overafter_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overafter_tbox_tbox", + "sqlfn": "tbox_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_box_bbox_pos" + }, + { + "name": "overbefore_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overbefore_tbox_tbox", + "sqlfn": "tbox_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_box_bbox_pos" + }, + { + "name": "overleft_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overleft_tbox_tbox", + "sqlfn": "tbox_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_box_bbox_pos" + }, + { + "name": "overright_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overright_tbox_tbox", + "sqlfn": "tbox_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_box_bbox_pos" + }, + { + "name": "right_tbox_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Right_tbox_tbox", + "sqlfn": "tbox_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_box_bbox_pos" + }, + { + "name": "tbox_cmp", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_cmp", + "sqlfn": "tbox_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_box_comp" + }, + { + "name": "tbox_eq", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_eq", + "sqlfn": "tbox_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_box_comp" + }, + { + "name": "tbox_ge", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_ge", + "sqlfn": "tbox_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_box_comp" + }, + { + "name": "tbox_gt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_gt", + "sqlfn": "tbox_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_box_comp" + }, + { + "name": "tbox_le", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_le", + "sqlfn": "tbox_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_box_comp" + }, + { + "name": "tbox_lt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_lt", + "sqlfn": "tbox_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_box_comp" + }, + { + "name": "tbox_ne", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_ne", + "sqlfn": "tbox_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_box_comp" + }, + { + "name": "tbigint_from_mfjson", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbigint_in", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbigint_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbool_from_mfjson", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbool_in", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbool_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "temporal_as_hexwkb", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Temporal_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_inout" + }, + { + "name": "temporal_as_mfjson", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "with_bbox", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "flags", + "cType": "int", + "canonical": "int" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + }, + { + "name": "srs", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Temporal_as_mfjson", + "sqlfn": "asMFJSON", + "sqlArity": 1, + "sqlArityMax": 4, + "group": "meos_temporal_inout" + }, + { + "name": "temporal_as_wkb", + "file": "meos.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Temporal_recv", + "sqlfn": "tint_recv", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_inout" + }, + { + "name": "temporal_from_hexwkb", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Temporal_from_hexwkb", + "sqlfn": "tintFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_inout" + }, + { + "name": "temporal_from_wkb", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Temporal_recv", + "sqlfn": "tint_recv", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_inout" + }, + { + "name": "meos_temporal_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_temporal_conversion" + }, + { + "name": "meos_temporal_from_arrow", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_temporal_conversion" + }, + { + "name": "meos_temporal_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_conversion" + }, + { + "name": "meos_set_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_set_from_arrow", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_set_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_span_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_span_from_arrow", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_span_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_spanset_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_spanset_from_arrow", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_spanset_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_setspan_conversion" + }, + { + "name": "meos_tbox_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "meos_tbox_from_arrow", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "meos_tbox_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "meos_stbox_to_arrow", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "out_schema", + "cType": "struct ArrowSchema *", + "canonical": "struct ArrowSchema *" + }, + { + "name": "out_array", + "cType": "struct ArrowArray *", + "canonical": "struct ArrowArray *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "meos_stbox_from_arrow", + "file": "meos.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "schema", + "cType": "const struct ArrowSchema *", + "canonical": "const struct ArrowSchema *" + }, + { + "name": "array", + "cType": "const struct ArrowArray *", + "canonical": "const struct ArrowArray *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "meos_stbox_arrow_roundtrip", + "file": "meos.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "group": "meos_box_conversion" + }, + { + "name": "tfloat_from_mfjson", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tfloat_in", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tfloat_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tint_from_mfjson", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tint_in", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tint_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "ttext_from_mfjson", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "ttext_in", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "ttext_out", + "file": "meos.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_inout" + }, + { + "name": "tbigint_from_base_temp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tbigintinst_make", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_constructor" + }, + { + "name": "tbigintseq_from_base_tstzset", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tbigintseq_from_base_tstzspan", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tbigintseqset_from_base_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tbool_from_base_temp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tboolinst_make", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_constructor" + }, + { + "name": "tboolseq_from_base_tstzset", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tboolseq_from_base_tstzspan", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tboolseqset_from_base_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "temporal_copy", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tfloat_from_base_temp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tfloatinst_make", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_constructor" + }, + { + "name": "tfloatseq_from_base_tstzset", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tfloatseq_from_base_tstzspan", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tfloatseqset_from_base_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tint_from_base_temp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tintinst_make", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_constructor" + }, + { + "name": "tintseq_from_base_tstzset", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tintseq_from_base_tstzspan", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tintseqset_from_base_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tsequence_make", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tsequence_constructor", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 4, + "group": "meos_temporal_constructor" + }, + { + "name": "tsequenceset_make", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tsequenceset_constructor", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_constructor" + }, + { + "name": "tsequenceset_make_gaps", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tsequenceset_constructor_gaps", + "sqlfn": "tintSeqSetGaps", + "sqlArity": 1, + "sqlArityMax": 4, + "group": "meos_temporal_constructor" + }, + { + "name": "ttext_from_base_temp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "ttextinst_make", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_constructor" + }, + { + "name": "ttextseq_from_base_tstzset", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "ttextseq_from_base_tstzspan", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "ttextseqset_from_base_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_temporal_constructor" + }, + { + "name": "tbigint_to_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbigint_to_tfloat", + "sqlfn": "tfloat", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tbigint_to_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbigint_to_tint", + "sqlfn": "tint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tbool_to_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbool_to_tint", + "sqlfn": "tint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "temporal_to_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_to_tstzspan", + "sqlfn": "timeSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tfloat_to_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_to_tbigint", + "sqlfn": "tbigint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tfloat_to_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_to_tint", + "sqlfn": "tint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tint_to_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tint_to_tfloat", + "sqlfn": "tfloat", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tint_to_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tint_to_tbigint", + "sqlfn": "tbigint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tnumber_to_span", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_to_span", + "sqlfn": "valueSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tnumber_to_tbox", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_temporal_conversion" + }, + { + "name": "tbigint_end_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbigint_max_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbigint_min_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbigint_start_value", + "file": "meos.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbigint_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "result", + "cType": "int64_t *", + "canonical": "int64_t *" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tbigint_values", + "file": "meos.h", + "returnType": { + "c": "int64_t *", + "canonical": "int64_t *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbool_end_value", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbool_start_value", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tbool_value_at_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tbool_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tbool_values", + "file": "meos.h", + "returnType": { + "c": "bool *", + "canonical": "bool *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_duration", + "file": "meos.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_end_instant", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_instant", + "sqlfn": "endInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_end_sequence", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_sequence", + "sqlfn": "endSequence", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_end_timestamptz", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_timestamptz", + "sqlfn": "endTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_hash", + "file": "meos.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_hash", + "sqlfn": "tint_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_instant_n", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_instant_n", + "sqlfn": "instantN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_instants", + "file": "meos.h", + "returnType": { + "c": "TInstant **", + "canonical": "struct TInstant **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_instants", + "sqlfn": "instants", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_instants_p", + "file": "meos.h", + "returnType": { + "c": "const TInstant **", + "canonical": "const struct TInstant **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_interp", + "file": "meos.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_interp", + "sqlfn": "interp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_lower_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_lower_inc", + "sqlfn": "lowerInc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_max_instant", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_instant", + "sqlfn": "maxInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_min_instant", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_min_instant", + "sqlfn": "minInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_num_instants", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_num_instants", + "sqlfn": "numInstants", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_num_sequences", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_num_sequences", + "sqlfn": "numSequences", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_num_timestamps", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_num_timestamps", + "sqlfn": "numTimestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_segm_duration", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "atleast", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_segments", + "file": "meos.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_segments", + "sqlfn": "segments", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_sequence_n", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_sequence_n", + "sqlfn": "sequenceN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_sequences", + "file": "meos.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_sequences", + "sqlfn": "sequences", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_start_instant", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_instant", + "sqlfn": "startInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_start_sequence", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_sequence", + "sqlfn": "startSequence", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_start_timestamptz", + "file": "meos.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_timestamptz", + "sqlfn": "startTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_stops", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "minduration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_subtype", + "file": "meos.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_subtype", + "sqlfn": "tempSubtype", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_basetype_name", + "file": "meos.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_basetype_name", + "sqlfn": "tempBasetype", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_time", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_time", + "sqlfn": "getTime", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_timestamps", + "file": "meos.h", + "returnType": { + "c": "TimestampTz *", + "canonical": "TimestampTz *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_timestamps", + "sqlfn": "timestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_timestamptz_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Temporal_timestamptz_n", + "sqlfn": "timestampN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_upper_inc", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_upper_inc", + "sqlfn": "upperInc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_end_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_min_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_max_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_start_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_value_at_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tfloat_values", + "file": "meos.h", + "returnType": { + "c": "double *", + "canonical": "double *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_end_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_max_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_min_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_start_value", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_value_at_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "tint_values", + "file": "meos.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tnumber_avg_value", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_avg_value", + "sqlfn": "avgValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumber_integral", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_accessor" + }, + { + "name": "tnumber_twavg", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_twavg", + "sqlfn": "twAvg", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "tnumber_valuespans", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_valuespans", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_end_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_max_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_min_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_start_value", + "file": "meos.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_value_at_timestamptz", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "text **", + "canonical": "text **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_value_n", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "text **", + "canonical": "text **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_accessor" + }, + { + "name": "ttext_values", + "file": "meos.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "float_degrees", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "value", + "cType": "double", + "canonical": "double" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Float_degrees", + "sqlfn": "degrees", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tbigint_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Tnumber_scale_value", + "sqlfn": "scaleValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tbigint_shift_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "width", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Tnumber_shift_scale_value", + "sqlfn": "shiftScaleValue", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_transf" + }, + { + "name": "tbigint_shift_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Tnumber_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temparr_round", + "file": "meos.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal **", + "canonical": "Temporal **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_transf" + }, + { + "name": "temporal_round", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_transf" + }, + { + "name": "temporal_scale_time", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_scale_time", + "sqlfn": "scaleTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_set_interp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_set_interp", + "sqlfn": "setInterp", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_shift_scale_time", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_shift_time", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_to_tinstant", + "file": "meos.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_to_tinstant", + "sqlfn": "tintInst", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_to_tsequence", + "file": "meos.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequence", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_to_tsequenceset", + "file": "meos.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_ceil", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_ceil", + "sqlfn": "ceil", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_degrees", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tfloat_degrees", + "sqlfn": "degrees", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_floor", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_floor", + "sqlfn": "floor", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_radians", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_radians", + "sqlfn": "radians", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tnumber_scale_value", + "sqlfn": "scaleValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_shift_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + }, + { + "name": "width", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tnumber_shift_scale_value", + "sqlfn": "shiftScaleValue", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_transf" + }, + { + "name": "tfloat_shift_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tnumber_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tint_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tnumber_scale_value", + "sqlfn": "scaleValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "tint_shift_scale_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + }, + { + "name": "width", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tnumber_shift_scale_value", + "sqlfn": "shiftScaleValue", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_transf" + }, + { + "name": "tint_shift_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tnumber_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_transf" + }, + { + "name": "temporal_append_tinstant", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tinstant", + "sqlfn": "appendInstant", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_append_tsequence", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tsequence", + "sqlfn": "appendSequence", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_delete_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_timestamptz", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_delete_tstzset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_delete_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspan", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_delete_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspanset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_insert", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_insert", + "sqlfn": "insert", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_merge", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_merge", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_merge_array", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temparr", + "cType": "Temporal **", + "canonical": "Temporal **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_merge_array", + "sqlfn": "merge", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_modif" + }, + { + "name": "temporal_update", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_update", + "sqlfn": "update", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_modif" + }, + { + "name": "tbool_at_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tbool_minus_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_after_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_after_timestamptz", + "sqlfn": "afterTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_max", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_at_max", + "sqlfn": "atMax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_min", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_at_min", + "sqlfn": "atMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_at_timestamptz", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_tstzset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Temporal_at_tstzset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Temporal_at_tstzspan", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Temporal_at_tstzspanset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_at_values", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Temporal_at_values", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_before_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_before_timestamptz", + "sqlfn": "beforeTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_max", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_minus_max", + "sqlfn": "minusMax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_min", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_minus_min", + "sqlfn": "minusMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_timestamptz", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_minus_timestamptz", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_tstzset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Temporal_minus_tstzset", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_tstzspan", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Temporal_minus_tstzspan", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_tstzspanset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Temporal_minus_tstzspanset", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_minus_values", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Temporal_minus_values", + "sqlfn": "minusValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tfloat_at_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tfloat_minus_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tint_at_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tint_minus_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_at_span", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tnumber_at_span", + "sqlfn": "atSpan", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_at_spanset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tnumber_at_spanset", + "sqlfn": "atSpanset", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_at_tbox", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tnumber_at_tbox", + "sqlfn": "atTbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_minus_span", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tnumber_minus_span", + "sqlfn": "minusSpan", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_minus_spanset", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tnumber_minus_spanset", + "sqlfn": "minusSpanset", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "tnumber_minus_tbox", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tnumber_minus_tbox", + "sqlfn": "minusTbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "ttext_at_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "ttext_minus_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "text *", + "canonical": "text *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_restrict" + }, + { + "name": "temporal_cmp", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_cmp", + "sqlfn": "tint_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_eq", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "ownership": "caller", + "nullable": true, + "doc": "Returns the temporal equality between two temporal values.", + "meos": { + "temporalDim": "any", + "spatialDim": null, + "interpolation": false, + "subtype": "any" + }, + "mdbC": "Temporal_eq", + "sqlfn": "tint_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_ge", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_gt", + "sqlfn": "tint_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_gt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_ge", + "sqlfn": "tint_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_le", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_le", + "sqlfn": "tint_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_lt", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_lt", + "sqlfn": "tint_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_temporal_comp_trad" + }, + { + "name": "temporal_ne", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_ne", + "sqlfn": "tint_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_comp_trad" + }, + { + "name": "always_eq_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_temporal_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_eq_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ge_base_temporal", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ge_base_temporal", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ge_base_temporal", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_ge_temporal_base", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ge_temporal_temporal", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ge_base_temporal", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_ge_temporal_base", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_ge_temporal_base", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ge_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_ge_temporal_base", + "sqlfn": "aGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_gt_base_temporal", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_gt_base_temporal", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_gt_base_temporal", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_gt_temporal_base", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_gt_temporal_temporal", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_gt_base_temporal", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_gt_temporal_base", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_gt_temporal_base", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_gt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_gt_temporal_base", + "sqlfn": "aGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_le_base_temporal", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_le_base_temporal", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_le_base_temporal", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_le_temporal_base", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_le_temporal_temporal", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_le_base_temporal", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_le_temporal_base", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_le_temporal_base", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_le_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_le_temporal_base", + "sqlfn": "aLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_lt_base_temporal", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_lt_base_temporal", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_lt_base_temporal", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_lt_temporal_temporal", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_lt_base_temporal", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_lt_temporal_base", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_lt_temporal_base", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_lt_temporal_base", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_lt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_lt_temporal_base", + "sqlfn": "aLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_temporal_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "always_ne_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_temporal_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_eq_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ge_base_temporal", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ge_base_temporal", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ge_base_temporal", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_ge_temporal_base", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ge_temporal_temporal", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ge_base_temporal", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_ge_temporal_base", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_ge_temporal_base", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ge_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_ge_temporal_base", + "sqlfn": "eGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_gt_base_temporal", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_gt_base_temporal", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_gt_base_temporal", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_gt_temporal_base", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_gt_temporal_temporal", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_gt_base_temporal", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_gt_temporal_base", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_gt_temporal_base", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_gt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_gt_temporal_base", + "sqlfn": "eGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_le_base_temporal", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_le_base_temporal", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_le_base_temporal", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_le_temporal_base", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_le_temporal_temporal", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_le_base_temporal", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_le_temporal_base", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_le_temporal_base", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_le_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_le_temporal_base", + "sqlfn": "eLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<=", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_lt_base_temporal", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_lt_base_temporal", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_lt_base_temporal", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_lt_temporal_base", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_lt_temporal_temporal", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_lt_base_temporal", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_lt_temporal_base", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_lt_temporal_base", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_lt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_lt_temporal_base", + "sqlfn": "eLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_int_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_temporal_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_text_ttext", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "ever_ne_ttext_text", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_temporal_comp_ever" + }, + { + "name": "teq_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_base_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_base_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_base_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Teq_temporal_base", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_temporal_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_base_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Teq_temporal_base", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Teq_temporal_base", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "teq_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Teq_temporal_base", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tge_base_temporal", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tge_base_temporal", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tge_temporal_temporal", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tge_base_temporal", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tge_temporal_base", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tge_temporal_base", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tge_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Tge_temporal_base", + "sqlfn": "tGe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgt_base_temporal", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgt_base_temporal", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgt_temporal_temporal", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgt_base_temporal", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tgt_temporal_base", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tgt_temporal_base", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tgt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Tgt_temporal_base", + "sqlfn": "tGt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tle_base_temporal", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tle_base_temporal", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tle_temporal_temporal", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tle_base_temporal", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tle_temporal_base", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tle_temporal_base", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tle_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Tle_temporal_base", + "sqlfn": "tLe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<=", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tlt_base_temporal", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tlt_base_temporal", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tlt_temporal_temporal", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tlt_base_temporal", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tlt_temporal_base", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tlt_temporal_base", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tlt_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Tlt_temporal_base", + "sqlfn": "tLt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_base_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_base_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_base_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tne_temporal_base", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_temporal_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_base_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tne_temporal_base", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tne_temporal_base", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "tne_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Tne_temporal_base", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_temporal_comp_temp" + }, + { + "name": "temporal_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_spans", + "sqlfn": "spans", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_temporal_bbox_split" + }, + { + "name": "temporal_split_each_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "elem_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_split_each_n_spans", + "sqlfn": "splitEachNSpans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_bbox_split" + }, + { + "name": "temporal_split_n_spans", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "span_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_split_n_spans", + "sqlfn": "splitNSpans", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_bbox_split" + }, + { + "name": "tnumber_split_each_n_tboxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "elem_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tnumber_split_each_n_tboxes", + "sqlfn": "splitEachNTboxes", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_bbox_split" + }, + { + "name": "tnumber_split_n_tboxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tnumber_split_n_tboxes", + "sqlfn": "splitNTboxes", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_bbox_split" + }, + { + "name": "tnumber_tboxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tnumber_tboxes", + "sqlfn": "tboxes", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_bbox_split" + }, + { + "name": "adjacent_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adjacent_temporal_temporal", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "adjacent_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Adjacent_temporal_tstzspan", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "adjacent_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Adjacent_tnumber_numspan", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "adjacent_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Adjacent_tnumber_tbox", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "adjacent_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adjacent_tnumber_tnumber", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_numspan_tnumber", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_tbox_tnumber", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_temporal_temporal", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_temporal_tstzspan", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contained_tnumber_numspan", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Contained_tnumber_tbox", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_tnumber_tnumber", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contained_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_tstzspan_temporal", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_numspan_tnumber", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_tbox_tnumber", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contains_temporal_tstzspan", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_temporal_temporal", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Contains_tnumber_numspan", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Contains_tnumber_tbox", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_tnumber_tnumber", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "contains_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_tstzspan_temporal", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "overlaps_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overlaps_temporal_temporal", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "overlaps_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overlaps_temporal_tstzspan", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "overlaps_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overlaps_tnumber_numspan", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "overlaps_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overlaps_tnumber_tbox", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "overlaps_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overlaps_tnumber_tnumber", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "same_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Same_temporal_temporal", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "same_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Same_temporal_tstzspan", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "same_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Same_tnumber_numspan", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "same_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Same_tnumber_tbox", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "same_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Same_tnumber_tnumber", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_temporal_bbox_topo" + }, + { + "name": "after_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_tbox_tnumber", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "after_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "After_temporal_tstzspan", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "after_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_temporal_temporal", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "after_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "After_tnumber_tbox", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "after_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_tnumber_tnumber", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "after_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_tstzspan_temporal", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_tbox_tnumber", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Before_temporal_tstzspan", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_temporal_temporal", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Before_tnumber_tbox", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_tnumber_tnumber", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "before_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_tstzspan_temporal", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "left_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Left_tbox_tnumber", + "sqlfn": "temporal_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "left_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Left_numspan_tnumber", + "sqlfn": "temporal_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "left_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Left_tnumber_numspan", + "sqlfn": "temporal_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "left_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Left_tnumber_tbox", + "sqlfn": "temporal_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "left_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Left_tnumber_tnumber", + "sqlfn": "temporal_left", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_tbox_tnumber", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overafter_temporal_tstzspan", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_temporal_temporal", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overafter_tnumber_tbox", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_tnumber_tnumber", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overafter_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_tstzspan_temporal", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_tbox_tnumber", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_temporal_tstzspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overbefore_temporal_tstzspan", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_temporal_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_temporal_temporal", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overbefore_tnumber_tbox", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_tnumber_tnumber", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overbefore_tstzspan_temporal", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_tstzspan_temporal", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overleft_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overleft_numspan_tnumber", + "sqlfn": "temporal_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overleft_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overleft_tbox_tnumber", + "sqlfn": "temporal_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overleft_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overleft_tnumber_numspan", + "sqlfn": "temporal_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overleft_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overleft_tnumber_tbox", + "sqlfn": "temporal_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overleft_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overleft_tnumber_tnumber", + "sqlfn": "temporal_overleft", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overright_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overright_numspan_tnumber", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overright_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overright_tbox_tnumber", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overright_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Overright_tnumber_numspan", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overright_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Overright_tnumber_tbox", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "overright_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overright_tnumber_tnumber", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "right_numspan_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Right_numspan_tnumber", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "right_tbox_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Right_tbox_tnumber", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "right_tnumber_numspan", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Right_tnumber_numspan", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "right_tnumber_tbox", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Right_tnumber_tbox", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "right_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Right_tnumber_tnumber", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_temporal_bbox_pos" + }, + { + "name": "tand_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tand_bool_tbool", + "sqlfn": "temporal_and", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&", + "group": "meos_temporal_bool" + }, + { + "name": "tand_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tand_tbool_bool", + "sqlfn": "temporal_and", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&", + "group": "meos_temporal_bool" + }, + { + "name": "tand_tbool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tand_tbool_tbool", + "sqlfn": "temporal_and", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&", + "group": "meos_temporal_bool" + }, + { + "name": "tbool_when_true", + "file": "meos.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbool_when_true", + "sqlfn": "whenTrue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_bool" + }, + { + "name": "tnot_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnot_tbool", + "sqlfn": "temporal_not", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "~", + "group": "meos_temporal_bool" + }, + { + "name": "tor_bool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tor_bool_tbool", + "sqlfn": "temporal_or", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|", + "group": "meos_temporal_bool" + }, + { + "name": "tor_tbool_bool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tor_tbool_bool", + "sqlfn": "temporal_or", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|", + "group": "meos_temporal_bool" + }, + { + "name": "tor_tbool_tbool", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tor_tbool_tbool", + "sqlfn": "temporal_or", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|", + "group": "meos_temporal_bool" + }, + { + "name": "add_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Add_number_tnumber", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Add_number_tnumber", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Add_number_tnumber", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Add_tnumber_number", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Add_tnumber_number", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Add_tnumber_number", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "add_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tnumber2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Add_tnumber_tnumber", + "sqlfn": "tAdd", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_temporal_math" + }, + { + "name": "div_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Div_number_tnumber", + "sqlfn": "tDiv", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/", + "group": "meos_temporal_math" + }, + { + "name": "div_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Div_number_tnumber", + "sqlfn": "tDiv", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/", + "group": "meos_temporal_math" + }, + { + "name": "div_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Div_number_tnumber", + "sqlfn": "tDiv", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/", + "group": "meos_temporal_math" + }, + { + "name": "div_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_temporal_math" + }, + { + "name": "div_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Div_tnumber_number", + "sqlfn": "tDiv", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/", + "group": "meos_temporal_math" + }, + { + "name": "div_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_temporal_math" + }, + { + "name": "div_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tnumber2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Div_tnumber_tnumber", + "sqlfn": "tDiv", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/", + "group": "meos_temporal_math" + }, + { + "name": "mul_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Mul_number_tnumber", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Mul_number_tnumber", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Mul_number_tnumber", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Mul_tnumber_number", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Mul_tnumber_number", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Mul_tnumber_number", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "mul_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tnumber2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Mul_tnumber_tnumber", + "sqlfn": "tMul", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_temporal_math" + }, + { + "name": "sub_bigint_tbigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Sub_number_tnumber", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_float_tfloat", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Sub_number_tnumber", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_int_tint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Sub_number_tnumber", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_tbigint_bigint", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "mdbC": "Sub_tnumber_number", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Sub_tnumber_number", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Sub_tnumber_number", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "sub_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tnumber1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tnumber2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Sub_tnumber_tnumber", + "sqlfn": "tSub", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_temporal_math" + }, + { + "name": "temporal_derivative", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_derivative", + "sqlfn": "derivative", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_exp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_exp", + "sqlfn": "ln", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_ln", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_ln", + "sqlfn": "ln", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_log10", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_log10", + "sqlfn": "ln", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_sin", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_sin", + "sqlfn": "sin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_cos", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_cos", + "sqlfn": "cos", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tfloat_tan", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_tan", + "sqlfn": "tan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tnumber_abs", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_abs", + "sqlfn": "abs", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tnumber_trend", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_trend", + "sqlfn": "trend", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "float_angular_difference", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "degrees1", + "cType": "double", + "canonical": "double" + }, + { + "name": "degrees2", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tnumber_angular_difference", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_angular_difference", + "sqlfn": "angularDifference", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "tnumber_delta_value", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_delta_value", + "sqlfn": "deltaValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_math" + }, + { + "name": "textcat_text_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Textcat_text_ttext", + "sqlfn": "tConcat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_temporal_text" + }, + { + "name": "textcat_ttext_text", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + } + ], + "mdbC": "Textcat_ttext_text", + "sqlfn": "tConcat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_temporal_text" + }, + { + "name": "textcat_ttext_ttext", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Textcat_ttext_ttext", + "sqlfn": "tConcat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_temporal_text" + }, + { + "name": "ttext_initcap", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_text" + }, + { + "name": "ttext_upper", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_text" + }, + { + "name": "ttext_lower", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_text" + }, + { + "name": "tdistance_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdistance_tnumber_number", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_temporal_dist" + }, + { + "name": "tdistance_tint_int", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tdistance_tnumber_number", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_temporal_dist" + }, + { + "name": "tdistance_tnumber_tnumber", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdistance_tnumber_tnumber", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_temporal_dist" + }, + { + "name": "nad_tboxfloat_tboxfloat", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tbox_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tboxint_tboxint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tbox_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tfloat_float", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "NAD_tnumber_number", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tfloat_tfloat", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tnumber_tnumber", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tfloat_tbox", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tnumber_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tint_int", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "NAD_tnumber_number", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tint_tbox", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tnumber_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "nad_tint_tint", + "file": "meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tnumber_tnumber", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_dist" + }, + { + "name": "tbool_tand_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbool_tand_transfn", + "sqlfn": "tAnd", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tbool_tand_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tbool_tand_combinefn", + "sqlfn": "tAnd", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tbool_tor_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbool_tor_transfn", + "sqlfn": "tOr", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tbool_tor_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tbool_tor_combinefn", + "sqlfn": "tOr", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_merge_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_merge_transfn", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_merge_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Temporal_merge_combinefn", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_tagg_finalfn", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Temporal_tagg_finalfn", + "sqlfn": "tCount", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_tcount_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_tcount_transfn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_tcount_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Temporal_tcount_combinefn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tmax_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_tmax_transfn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tmax_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tfloat_tmax_combinefn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tmin_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_tmin_transfn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tmin_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tfloat_tmin_combinefn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tsum_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tfloat_tsum_transfn", + "sqlfn": "tSum", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_tsum_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tfloat_tsum_combinefn", + "sqlfn": "tSum", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_wmax_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tfloat_wmax_transfn", + "sqlfn": "wMax", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_wmin_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tfloat_wmin_transfn", + "sqlfn": "wMin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tfloat_wsum_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tfloat_wsum_transfn", + "sqlfn": "wSum", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "timestamptz_tcount_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Timestamptz_tcount_transfn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tmax_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tint_tmax_transfn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tmax_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tint_tmax_combinefn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tmin_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tint_tmin_transfn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tmin_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tint_tmin_combinefn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tsum_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tint_tsum_transfn", + "sqlfn": "tSum", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_tsum_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tint_tsum_combinefn", + "sqlfn": "tSum", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tint_wmax_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tint_wmax_transfn", + "sqlfn": "wMax", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tint_wmin_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tint_wmin_transfn", + "sqlfn": "wMin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tint_wsum_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tint_wsum_transfn", + "sqlfn": "wSum", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tnumber_extent_transfn", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "TBox *", + "canonical": "struct TBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tnumber_tavg_finalfn", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tnumber_tavg_finalfn", + "sqlfn": "tAvg", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_agg" + }, + { + "name": "tnumber_tavg_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnumber_tavg_transfn", + "sqlfn": "tAvg", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tnumber_tavg_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tnumber_tavg_combinefn", + "sqlfn": "tAvg", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tnumber_wavg_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Tnumber_wavg_transfn", + "sqlfn": "wAvg", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_temporal_agg" + }, + { + "name": "tstzset_tcount_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tstzset_tcount_transfn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tstzspan_tcount_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tstzspan_tcount_transfn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "tstzspanset_tcount_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_tcount_transfn", + "sqlfn": "tCount", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "ttext_tmax_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_tmax_transfn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "ttext_tmax_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Ttext_tmax_combinefn", + "sqlfn": "tMax", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "ttext_tmin_transfn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_tmin_transfn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "ttext_tmin_combinefn", + "file": "meos.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Ttext_tmin_combinefn", + "sqlfn": "tMin", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_agg" + }, + { + "name": "temporal_simplify_dp", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "synchronized", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_simplify_dp", + "sqlfn": "douglasPeuckerSimplify", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_simplify" + }, + { + "name": "temporal_simplify_max_dist", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "synchronized", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_simplify_max_dist", + "sqlfn": "maxDistSimplify", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_simplify" + }, + { + "name": "temporal_simplify_min_dist", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Temporal_simplify_min_dist", + "sqlfn": "minDistSimplify", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_simplify" + }, + { + "name": "temporal_simplify_min_tdelta", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "mint", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_simplify_min_tdelta", + "sqlfn": "minTimeDeltaSimplify", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_analytics_simplify" + }, + { + "name": "temporal_tprecision", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "origin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_tprecision", + "sqlfn": "tPrecision", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_reduction" + }, + { + "name": "temporal_tsample", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "origin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_tsample", + "sqlfn": "tSample", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_temporal_analytics_reduction" + }, + { + "name": "temporal_dyntimewarp_distance", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_dyntimewarp_distance", + "sqlfn": "dynTimeWarpDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_analytics_similarity" + }, + { + "name": "temporal_dyntimewarp_path", + "file": "meos.h", + "returnType": { + "c": "Match *", + "canonical": "Match *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_dyntimewarp_path", + "sqlfn": "dynTimeWarpPath", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_analytics_similarity" + }, + { + "name": "temporal_frechet_distance", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_frechet_distance", + "sqlfn": "frechetDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_analytics_similarity" + }, + { + "name": "temporal_frechet_path", + "file": "meos.h", + "returnType": { + "c": "Match *", + "canonical": "Match *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_frechet_path", + "sqlfn": "frechetDistancePath", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_analytics_similarity" + }, + { + "name": "temporal_hausdorff_distance", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_temporal_analytics_similarity" + }, + { + "name": "temporal_average_hausdorff_distance", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "temporal_lcss_distance", + "file": "meos.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "epsilon", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "temporal_ext_kalman_filter", + "file": "meos.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gate", + "cType": "double", + "canonical": "double" + }, + { + "name": "q", + "cType": "double", + "canonical": "double" + }, + { + "name": "variance", + "cType": "double", + "canonical": "double" + }, + { + "name": "to_drop", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_temporal_analytics_simplify" + }, + { + "name": "temporal_time_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "origin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_time_bins", + "sqlfn": "timeSpans", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "temporal_time_split", + "file": "meos.h", + "returnType": { + "c": "TimeSplit", + "canonical": "struct TimeSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_time_split", + "sqlfn": "timeSplit", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_time_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_value_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_value_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_value_split", + "file": "meos.h", + "returnType": { + "c": "FloatSplit", + "canonical": "FloatSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "size", + "cType": "double", + "canonical": "double" + }, + { + "name": "origin", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tnumber_value_split", + "sqlfn": "valueSplit", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_value_time_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloat_value_time_split", + "file": "meos.h", + "returnType": { + "c": "FloatTimeSplit", + "canonical": "struct FloatTimeSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tnumber_value_time_split", + "sqlfn": "valueTimeSplit", + "sqlArity": 3, + "sqlArityMax": 5, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloatbox_time_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_time_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloatbox_value_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_value_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tfloatbox_value_time_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "vsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "double", + "canonical": "double" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_value_time_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 3, + "sqlArityMax": 5, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_time_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_value_bins", + "file": "meos.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_value_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_value_split", + "file": "meos.h", + "returnType": { + "c": "IntSplit", + "canonical": "IntSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tnumber_value_split", + "sqlfn": "valueSplit", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_value_time_boxes", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tint_value_time_split", + "file": "meos.h", + "returnType": { + "c": "IntTimeSplit", + "canonical": "struct IntTimeSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "size", + "cType": "int", + "canonical": "int" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tnumber_value_time_split", + "sqlfn": "valueTimeSplit", + "sqlArity": 3, + "sqlArityMax": 5, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tintbox_time_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_time_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tintbox_value_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "xsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "xorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_value_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "tintbox_value_time_tiles", + "file": "meos.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "xsize", + "cType": "int", + "canonical": "int" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "xorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tbox_value_time_tiles", + "sqlfn": "valueTimeTiles", + "sqlArity": 3, + "sqlArityMax": 5, + "group": "meos_temporal_analytics_tile" + }, + { + "name": "box3d_from_gbox", + "file": "meos_geo.h", + "returnType": { + "c": "BOX3D *", + "canonical": "BOX3D *" + }, + "params": [ + { + "name": "box", + "cType": "const GBOX *", + "canonical": "const GBOX *" + } + ] + }, + { + "name": "box3d_make", + "file": "meos_geo.h", + "returnType": { + "c": "BOX3D *", + "canonical": "BOX3D *" + }, + "params": [ + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "box3d_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const BOX3D *", + "canonical": "const BOX3D *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "gbox_make", + "file": "meos_geo.h", + "returnType": { + "c": "GBOX *", + "canonical": "GBOX *" + }, + "params": [ + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmax", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "gbox_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const GBOX *", + "canonical": "const GBOX *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_as_ewkb", + "file": "meos_geo.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "endian", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_as_ewkt", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_as_geojson", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "option", + "cType": "int", + "canonical": "int" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + }, + { + "name": "srs", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_as_hexewkb", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "endian", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_as_text", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_from_ewkb", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "wkb_size", + "cType": "size_t", + "canonical": "size_t" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_from_geojson", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geojson", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_from_text", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "wkt", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geog_from_hexewkb", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "wkt", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geog_in", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geom_from_hexewkb", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "wkt", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geom_in", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "box3d_in", + "file": "meos_geo.h", + "returnType": { + "c": "BOX3D *", + "canonical": "BOX3D *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "gbox_in", + "file": "meos_geo.h", + "returnType": { + "c": "GBOX *", + "canonical": "GBOX *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_inout" + }, + { + "name": "geo_copy", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_constructor" + }, + { + "name": "geogpoint_make2d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_constructor" + }, + { + "name": "geogpoint_make3dz", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_constructor" + }, + { + "name": "geompoint_make2d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_constructor" + }, + { + "name": "geompoint_make3dz", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_constructor" + }, + { + "name": "geom_to_geog", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_conversion" + }, + { + "name": "geog_to_geom", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geog", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_conversion" + }, + { + "name": "geo_is_empty", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geo_is_unitary", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geo_typename", + "file": "meos_geo.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "type", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geog_area", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geog_centroid", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geog_length", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geog_perimeter", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geom_azimuth", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geom_length", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geom_perimeter", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "line_numpoints", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "line_point_n", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_accessor" + }, + { + "name": "geo_reverse", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_transf" + }, + { + "name": "geo_round", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Geo_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_base_transf" + }, + { + "name": "geo_set_srid", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_base_srid" + }, + { + "name": "geo_srid", + "file": "meos_geo.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_srid" + }, + { + "name": "geo_transform", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "srid_to", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_base_srid" + }, + { + "name": "geo_transform_pipeline", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "pipeline", + "cType": "char *", + "canonical": "char *" + }, + { + "name": "srid_to", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_srid" + }, + { + "name": "geo_collect_garray", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gsarr", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_makeline_garray", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gsarr", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_num_points", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_num_geos", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_geo_n", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_pointarr", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_points", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_array_union", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gsarr", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_boundary", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_buffer", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "size", + "cType": "double", + "canonical": "double" + }, + { + "name": "params", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_centroid", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_convex_hull", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_difference2d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_intersection2d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_intersection2d_coll", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_min_bounding_radius", + "file": "meos_geo.h", + "returnType": { + "c": "MinBoundingCircle", + "canonical": "struct MinBoundingCircle" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_shortestline2d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_shortestline3d", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geom_unary_union", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "prec", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "line_interpolate_point", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "distance_fraction", + "cType": "double", + "canonical": "double" + }, + { + "name": "repeat", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "line_locate_point", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "line_substring", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "from", + "cType": "double", + "canonical": "double" + }, + { + "name": "to", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geog_dwithin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "g1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "g2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geog_intersects", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "use_spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_contains", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_covers", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_disjoint2d", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_dwithin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_dwithin2d", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_dwithin3d", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_intersects", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_intersects2d", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_intersects3d", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_relate_pattern", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "patt", + "cType": "char *", + "canonical": "char *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geom_touches", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_rel" + }, + { + "name": "geo_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Geo_stboxes", + "sqlfn": "stboxes", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_base_bbox" + }, + { + "name": "geo_split_each_n_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "elem_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_bbox" + }, + { + "name": "geo_split_n_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "box_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_bbox" + }, + { + "name": "geog_distance", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "g1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "g2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_distance" + }, + { + "name": "geom_distance2d", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_distance" + }, + { + "name": "geom_distance3d", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_distance" + }, + { + "name": "geo_equals", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_comp" + }, + { + "name": "geo_same", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_base_comp" + }, + { + "name": "geogset_in", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_inout" + }, + { + "name": "geomset_in", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_inout" + }, + { + "name": "spatialset_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_inout" + }, + { + "name": "spatialset_as_text", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spatialset_as_text", + "sqlfn": "asText", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_set_inout" + }, + { + "name": "spatialset_as_ewkt", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spatialset_as_ewkt", + "sqlfn": "asEWKT", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_set_inout" + }, + { + "name": "geoset_make", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_constructor" + }, + { + "name": "geo_to_set", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_conversion" + }, + { + "name": "geoset_end_value", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_accessor" + }, + { + "name": "geoset_start_value", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_accessor" + }, + { + "name": "geoset_value_n", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_set_accessor" + }, + { + "name": "geoset_values", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_accessor" + }, + { + "name": "contained_geo_set", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_geo_set_setops" + }, + { + "name": "contains_set_geo", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_geo_set_setops" + }, + { + "name": "geo_union_transfn", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_set_setops" + }, + { + "name": "intersection_geo_set", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_geo_set_setops" + }, + { + "name": "intersection_set_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_geo_set_setops" + }, + { + "name": "minus_geo_set", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_geo_set_setops" + }, + { + "name": "minus_set_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_geo_set_setops" + }, + { + "name": "union_geo_set", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_geo_set_setops" + }, + { + "name": "union_set_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_geo_set_setops" + }, + { + "name": "spatialset_set_srid", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Spatialset_set_srid", + "sqlfn": "setSRID", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_set_srid" + }, + { + "name": "spatialset_srid", + "file": "meos_geo.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Spatialset_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_set_srid" + }, + { + "name": "spatialset_transform", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Spatialset_transform", + "sqlfn": "transform", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_set_srid" + }, + { + "name": "spatialset_transform_pipeline", + "file": "meos_geo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pipelinestr", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Spatialset_transform_pipeline", + "sqlfn": "transformPipeline", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_geo_set_srid" + }, + { + "name": "stbox_as_hexwkb", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Stbox_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_inout" + }, + { + "name": "stbox_as_wkb", + "file": "meos_geo.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Stbox_recv", + "sqlfn": "stbox_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_inout" + }, + { + "name": "stbox_from_hexwkb", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Stbox_from_hexwkb", + "sqlfn": "stboxFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_inout" + }, + { + "name": "stbox_from_wkb", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Stbox_recv", + "sqlfn": "stbox_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_inout" + }, + { + "name": "stbox_in", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Stbox_in", + "sqlfn": "stbox_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_inout" + }, + { + "name": "stbox_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Stbox_out", + "sqlfn": "stbox_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_inout" + }, + { + "name": "geo_timestamptz_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Geo_timestamptz_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "::", + "group": "meos_geo_box_constructor" + }, + { + "name": "geo_tstzspan_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Geo_tstzspan_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "::", + "group": "meos_geo_box_constructor" + }, + { + "name": "stbox_copy", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "group": "meos_geo_box_constructor" + }, + { + "name": "stbox_make", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "hasx", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Stbox_constructor_x", + "sqlfn": "stbox", + "sqlArity": 4, + "sqlArityMax": 5, + "group": "meos_geo_box_constructor" + }, + { + "name": "geo_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geo_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "spatialset_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Spatialset_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "stbox_to_box3d", + "file": "meos_geo.h", + "returnType": { + "c": "BOX3D *", + "canonical": "BOX3D *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_to_box3d", + "sqlfn": "box3d", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "stbox_to_gbox", + "file": "meos_geo.h", + "returnType": { + "c": "GBOX *", + "canonical": "GBOX *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_to_box2d", + "sqlfn": "box2d", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "stbox_to_geo", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_to_geo", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "stbox_to_tstzspan", + "file": "meos_geo.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_to_tstzspan", + "sqlfn": "timeSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "timestamptz_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Timestamptz_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "tstzset_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tstzset_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "tstzspan_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tstzspan_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "tstzspanset_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tstzspanset_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "stbox_area", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Stbox_area", + "sqlfn": "area", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_hash", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_hash", + "sqlfn": "stbox_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_hash_extended", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Stbox_hash_extended", + "sqlfn": "stbox_hash_extended", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_hast", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_hast", + "sqlfn": "hasT", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_hasx", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_hasx", + "sqlfn": "hasX", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_hasz", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_hasz", + "sqlfn": "hasZ", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_isgeodetic", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_isgeodetic", + "sqlfn": "isGeodetic", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_perimeter", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "spheroid", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Stbox_perimeter", + "sqlfn": "area", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_tmax", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Stbox_tmax", + "sqlfn": "Tmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_tmax_inc", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Stbox_tmax_inc", + "sqlfn": "Tmax_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_tmin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Stbox_tmin", + "sqlfn": "Tmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_tmin_inc", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "bool *", + "canonical": "bool *" + } + ], + "mdbC": "Stbox_tmin_inc", + "sqlfn": "Tmin_inc", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_volume", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_volume", + "sqlfn": "volume", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_xmax", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_xmax", + "sqlfn": "Xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_xmin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_xmin", + "sqlfn": "Xmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_ymax", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_ymax", + "sqlfn": "Ymax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_ymin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_ymin", + "sqlfn": "Ymin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_zmax", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_zmax", + "sqlfn": "Zmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_zmin", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Stbox_zmin", + "sqlfn": "Zmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_accessor" + }, + { + "name": "stbox_expand_space", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Stbox_expand_space", + "sqlfn": "expandSpace", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_expand_time", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Stbox_expand_time", + "sqlfn": "Stbox_expand_time", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_get_space", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_get_space", + "sqlfn": "getSpace", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_quad_split", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Stbox_quad_split", + "sqlfn": "stbox_intersection", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "*", + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_round", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Stbox_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_shift_scale_time", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Stbox_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_transf" + }, + { + "name": "stboxarr_round", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "boxarr", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Stboxarr_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_transf" + }, + { + "name": "stbox_set_srid", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Stbox_set_srid", + "sqlfn": "setSRID", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_srid" + }, + { + "name": "stbox_srid", + "file": "meos_geo.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_box_srid" + }, + { + "name": "stbox_transform", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Stbox_transform", + "sqlfn": "transform", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_srid" + }, + { + "name": "stbox_transform_pipeline", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "pipelinestr", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Stbox_transform_pipeline", + "sqlfn": "transformPipeline", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_geo_box_srid" + }, + { + "name": "adjacent_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Adjacent_stbox_stbox", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_geo_box_topo" + }, + { + "name": "contained_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Contained_stbox_stbox", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_geo_box_topo" + }, + { + "name": "contains_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Contains_stbox_stbox", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_geo_box_topo" + }, + { + "name": "overlaps_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overlaps_stbox_stbox", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_geo_box_topo" + }, + { + "name": "same_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Same_stbox_stbox", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_geo_box_topo" + }, + { + "name": "above_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Above_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|>>", + "group": "meos_geo_box_pos" + }, + { + "name": "after_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "After_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_geo_box_pos" + }, + { + "name": "back_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Back_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/>>", + "group": "meos_geo_box_pos" + }, + { + "name": "before_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Before_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_geo_box_pos" + }, + { + "name": "below_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Below_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<|", + "group": "meos_geo_box_pos" + }, + { + "name": "front_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Front_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_geo_box_pos" + }, + { + "name": "overabove_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overabove_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|&>", + "group": "meos_geo_box_pos" + }, + { + "name": "overafter_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overafter_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_geo_box_pos" + }, + { + "name": "overback_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overback_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/&>", + "group": "meos_geo_box_pos" + }, + { + "name": "overbefore_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overbefore_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_geo_box_pos" + }, + { + "name": "overbelow_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overbelow_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<|", + "group": "meos_geo_box_pos" + }, + { + "name": "overfront_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overfront_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&", + "group": "meos_geo_box_pos" + }, + { + "name": "overright_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overright_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<", + "group": "meos_geo_box_pos" + }, + { + "name": "right_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Right_stbox_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<", + "group": "meos_geo_box_pos" + }, + { + "name": "union_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Union_stbox_stbox", + "sqlfn": "stbox_union", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_geo_box_set" + }, + { + "name": "intersection_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Intersection_stbox_stbox", + "sqlfn": "stbox_intersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_geo_box_set" + }, + { + "name": "stbox_cmp", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_cmp", + "sqlfn": "stbox_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_eq", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_eq", + "sqlfn": "stbox_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_ge", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_ge", + "sqlfn": "stbox_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_gt", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_gt", + "sqlfn": "stbox_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_le", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_le", + "sqlfn": "stbox_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_lt", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_lt", + "sqlfn": "stbox_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_geo_box_comp" + }, + { + "name": "stbox_ne", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_ne", + "sqlfn": "stbox_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_geo_box_comp" + }, + { + "name": "tspatial_out", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeogpoint_from_mfjson", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeogpoint_in", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeography_from_mfjson", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeography_in", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeometry_from_mfjson", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeometry_in", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeompoint_from_mfjson", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tgeompoint_in", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_geo_inout" + }, + { + "name": "tspatial_as_ewkt", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tspatial_as_ewkt", + "sqlfn": "asEWKT", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_inout" + }, + { + "name": "tspatial_as_text", + "file": "meos_geo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tspatial_as_text", + "sqlfn": "asText", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_inout" + }, + { + "name": "tgeo_from_base_temp", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tgeoinst_make", + "file": "meos_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_constructor" + }, + { + "name": "tgeoseq_from_base_tstzset", + "file": "meos_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tgeoseq_from_base_tstzspan", + "file": "meos_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tgeoseqset_from_base_tstzspanset", + "file": "meos_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tpoint_from_base_temp", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tpointinst_make", + "file": "meos_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_constructor" + }, + { + "name": "tpointseq_from_base_tstzset", + "file": "meos_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tpointseq_from_base_tstzspan", + "file": "meos_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tpointseq_make_coords", + "file": "meos_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "xcoords", + "cType": "const double *", + "canonical": "const double *" + }, + { + "name": "ycoords", + "cType": "const double *", + "canonical": "const double *" + }, + { + "name": "zcoords", + "cType": "const double *", + "canonical": "const double *" + }, + { + "name": "times", + "cType": "const TimestampTz *", + "canonical": "const TimestampTz *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "tpointseqset_from_base_tstzspanset", + "file": "meos_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_geo_constructor" + }, + { + "name": "box3d_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const BOX3D *", + "canonical": "const BOX3D *" + } + ], + "mdbC": "Box3d_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_box_conversion" + }, + { + "name": "gbox_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const GBOX *", + "canonical": "const GBOX *" + } + ], + "group": "meos_geo_box_conversion" + }, + { + "name": "geomeas_to_tpoint", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geomeas_to_tpoint", + "sqlfn": "tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeogpoint_to_tgeography", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_to_tgeo", + "sqlfn": "tgeometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeography_to_tgeogpoint", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeo_to_tpoint", + "sqlfn": "tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeography_to_tgeometry", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeography_to_tgeometry", + "sqlfn": "tgeometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeometry_to_tgeography", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeometry_to_tgeography", + "sqlfn": "tgeography", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeometry_to_tgeompoint", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeo_to_tpoint", + "sqlfn": "tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tgeompoint_to_tgeometry", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_to_tgeo", + "sqlfn": "tgeometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tpoint_as_mvtgeom", + "file": "meos_geo.h", + "returnType": { + "c": "MvtGeom", + "canonical": "struct MvtGeom" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "bounds", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "extent", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "buffer", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "clip_geom", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tpoint_AsMVTGeom", + "sqlfn": "asMVTGeom", + "sqlArity": 2, + "sqlArityMax": 5, + "group": "meos_geo_conversion" + }, + { + "name": "tpoint_tfloat_to_geomeas", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "tpoint", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "measure", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "segmentize", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ], + "mdbC": "Tpoint_to_geomeas", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 2, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "tspatial_to_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tspatial_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_geo_conversion" + }, + { + "name": "bearing_point_point", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Bearing_point_point", + "sqlfn": "bearing", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "bearing_tpoint_point", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Bearing_tpoint_point", + "sqlfn": "bearing", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "bearing_tpoint_tpoint", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Bearing_tpoint_tpoint", + "sqlfn": "bearing", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_centroid", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeo_centroid", + "sqlfn": "centroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_convex_hull", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeo_convex_hull", + "sqlfn": "convexHull", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_end_value", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_start_value", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_traversed_area", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_value_at_timestamptz", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_value_n", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_values", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_angular_difference", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_angular_difference", + "sqlfn": "angularDifference", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_azimuth", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_azimuth", + "sqlfn": "azimuth", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_cumulative_length", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_cumulative_length", + "sqlfn": "cumulativeLength", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_direction", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpoint_direction", + "sqlfn": "direction", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_get_x", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_get_x", + "sqlfn": "getX", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_get_y", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_get_y", + "sqlfn": "getY", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_get_z", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_get_z", + "sqlfn": "getZ", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_is_simple", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_is_simple", + "sqlfn": "isSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_length", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_length", + "sqlfn": "length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_speed", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "ownership": "caller", + "nullable": true, + "doc": "Computes the instantaneous speed of a temporal point.", + "meos": { + "temporalDim": "sequence", + "spatialDim": null, + "interpolation": true, + "subtype": "TPoint" + }, + "mdbC": "Tpoint_speed", + "sqlfn": "speed", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_trajectory", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tpoint_trajectory", + "sqlfn": "trajectory", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_geo_accessor" + }, + { + "name": "tpoint_twcentroid", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_twcentroid", + "sqlfn": "twCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_accessor" + }, + { + "name": "tgeo_affine", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "a", + "cType": "const AFFINE *", + "canonical": "const AFFINE *" + } + ], + "mdbC": "Tgeo_affine", + "sqlfn": "affine", + "sqlArity": 13, + "sqlArityMax": 13, + "group": "meos_geo_transf" + }, + { + "name": "tgeo_scale", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "scale", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tgeo_scale", + "sqlfn": "scale", + "sqlArity": 2, + "sqlArityMax": 5, + "group": "meos_geo_transf" + }, + { + "name": "tpoint_make_simple", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tpoint_make_simple", + "sqlfn": "makeSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_transf" + }, + { + "name": "tspatial_srid", + "file": "meos_geo.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tspatial_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_srid" + }, + { + "name": "tspatial_set_srid", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Tspatial_set_srid", + "sqlfn": "setSRID", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_srid" + }, + { + "name": "tspatial_transform", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_geo_srid" + }, + { + "name": "tspatial_transform_pipeline", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pipelinestr", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_geo_srid" + }, + { + "name": "tgeo_at_geom", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tgeo_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tgeo_at_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_geo_restrict" + }, + { + "name": "tgeo_at_value", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tgeo_minus_geom", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tgeo_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tgeo_minus_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_minus_stbox", + "sqlfn": "minusStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_geo_restrict" + }, + { + "name": "tgeo_minus_value", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_at_elevation", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tgeo_at_elevation", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_at_geom", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tgeo_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_at_value", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_minus_elevation", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tgeo_minus_elevation", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_minus_geom", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tgeo_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "tpoint_minus_value", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_restrict" + }, + { + "name": "always_eq_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_geo_tgeo", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_geo_comp_ever" + }, + { + "name": "always_eq_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Always_eq_tgeo_geo", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_geo_comp_ever" + }, + { + "name": "always_eq_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_tgeo_tgeo", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_geo_comp_ever" + }, + { + "name": "always_ne_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_geo_tgeo", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "always_ne_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Always_ne_tgeo_geo", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "always_ne_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_tgeo_tgeo", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_eq_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_geo_tgeo", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_eq_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ever_eq_tgeo_geo", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_eq_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_tgeo_tgeo", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_ne_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_geo_tgeo", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_ne_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ever_ne_tgeo_geo", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "ever_ne_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_tgeo_tgeo", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_geo_comp_ever" + }, + { + "name": "teq_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_geo_tgeo", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_geo_comp_temp" + }, + { + "name": "teq_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Teq_tgeo_geo", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_geo_comp_temp" + }, + { + "name": "tne_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_geo_tgeo", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_geo_comp_temp" + }, + { + "name": "tne_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tne_tgeo_geo", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_geo_comp_temp" + }, + { + "name": "tgeo_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tgeo_stboxes", + "sqlfn": "stboxes", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_bbox_split" + }, + { + "name": "tgeo_space_boxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tgeo_space_boxes", + "sqlfn": "spaceBoxes", + "sqlArity": 4, + "sqlArityMax": 7, + "group": "meos_geo_tile" + }, + { + "name": "tgeo_space_time_boxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tgeo_space_time_boxes", + "sqlfn": "spaceTimeBoxes", + "sqlArity": 5, + "sqlArityMax": 9 + }, + { + "name": "tgeo_split_each_n_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "elem_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tgeo_split_each_n_stboxes", + "sqlfn": "splitEachNStboxes", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_bbox_split" + }, + { + "name": "tgeo_split_n_stboxes", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tgeo_split_n_stboxes", + "sqlfn": "splitNStboxes", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_bbox_split" + }, + { + "name": "adjacent_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Adjacent_tspatial_stbox", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_geo_bbox_topo" + }, + { + "name": "adjacent_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adjacent_tspatial_tspatial", + "sqlfn": "adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contained_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_stbox_tspatial", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contained_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Contained_tspatial_stbox", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contained_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contained_tspatial_tspatial", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contains_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_stbox_tspatial", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contains_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Contains_tspatial_stbox", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_geo_bbox_topo" + }, + { + "name": "contains_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_tspatial_tspatial", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_geo_bbox_topo" + }, + { + "name": "overlaps_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overlaps_tspatial_stbox", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_geo_bbox_topo" + }, + { + "name": "overlaps_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overlaps_tspatial_tspatial", + "sqlfn": "overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_geo_bbox_topo" + }, + { + "name": "same_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Same_tspatial_stbox", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_geo_bbox_topo" + }, + { + "name": "same_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Same_tspatial_tspatial", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_geo_bbox_topo" + }, + { + "name": "above_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Above_stbox_tspatial", + "sqlfn": "temporal_above", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "above_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Above_tspatial_stbox", + "sqlfn": "temporal_above", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "above_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Above_tspatial_tspatial", + "sqlfn": "temporal_above", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "after_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_stbox_tspatial", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "after_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "After_tspatial_stbox", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "after_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "After_tspatial_tspatial", + "sqlfn": "temporal_after", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "back_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Back_stbox_tspatial", + "sqlfn": "temporal_back", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "back_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Back_tspatial_stbox", + "sqlfn": "temporal_back", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "back_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Back_tspatial_tspatial", + "sqlfn": "temporal_back", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/>>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "before_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_stbox_tspatial", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "before_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Before_tspatial_stbox", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "before_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Before_tspatial_tspatial", + "sqlfn": "temporal_before", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "below_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Below_stbox_tspatial", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "below_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Below_tspatial_stbox", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "below_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Below_tspatial_tspatial", + "sqlfn": "temporal_below", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "front_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Front_stbox_tspatial", + "sqlfn": "temporal_front", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overabove_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overabove_tspatial_stbox", + "sqlfn": "temporal_overabove", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overabove_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overabove_tspatial_tspatial", + "sqlfn": "temporal_overabove", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overafter_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_stbox_tspatial", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overafter_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overafter_tspatial_stbox", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overafter_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overafter_tspatial_tspatial", + "sqlfn": "temporal_overafter", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overback_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overback_stbox_tspatial", + "sqlfn": "temporal_overback", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overback_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overback_tspatial_stbox", + "sqlfn": "temporal_overback", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_bbox_pos" + }, + { + "name": "overback_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overback_tspatial_tspatial", + "sqlfn": "temporal_overback", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "/&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbefore_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_stbox_tspatial", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbefore_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overbefore_tspatial_stbox", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbefore_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbefore_tspatial_tspatial", + "sqlfn": "temporal_overbefore", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<#", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbelow_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbelow_stbox_tspatial", + "sqlfn": "temporal_overbelow", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbelow_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overbelow_tspatial_stbox", + "sqlfn": "temporal_overbelow", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overbelow_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overbelow_tspatial_tspatial", + "sqlfn": "temporal_overbelow", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&<|", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overfront_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overfront_stbox_tspatial", + "sqlfn": "temporal_overfront", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overright_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Overright_tspatial_stbox", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "overright_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Overright_tspatial_tspatial", + "sqlfn": "temporal_overright", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "right_stbox_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Right_stbox_tspatial", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "right_tspatial_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Right_tspatial_stbox", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "right_tspatial_tspatial", + "file": "meos_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Right_tspatial_tspatial", + "sqlfn": "temporal_right", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">>", + "group": "meos_geo_bbox_pos" + }, + { + "name": "acontains_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_geo_tgeo", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "acontains_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Acontains_tgeo_geo", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "acontains_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_tgeo_tgeo", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "acovers_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "acovers_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "acovers_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "adisjoint_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Adisjoint_tgeo_geo", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "adisjoint_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adisjoint_tgeo_tgeo", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "adwithin_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_tgeo_geo", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_ever" + }, + { + "name": "adwithin_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_tgeo_tgeo", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_ever" + }, + { + "name": "aintersects_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Aintersects_tgeo_geo", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "aintersects_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Aintersects_tgeo_tgeo", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "atouches_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_tgeo_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "atouches_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Atouches_tgeo_tgeo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "atouches_tpoint_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_tpoint_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_spatial_rel_ever" + }, + { + "name": "econtains_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Econtains_geo_tgeo", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "econtains_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Econtains_tgeo_geo", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "econtains_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Econtains_tgeo_tgeo", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "ecovers_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_geo_tgeo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "ecovers_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ecovers_tgeo_geo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "ecovers_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_tgeo_tgeo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "edisjoint_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Edisjoint_tgeo_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "edisjoint_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Edisjoint_tgeo_tgeo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "edwithin_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_tgeo_geo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_ever" + }, + { + "name": "edwithin_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_tgeo_tgeo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_ever" + }, + { + "name": "eintersects_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Aintersects_tgeo_geo", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "eintersects_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Eintersects_tgeo_tgeo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "etouches_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Etouches_tgeo_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "etouches_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Etouches_tgeo_tgeo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "etouches_tpoint_geo", + "file": "meos_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_tpoint_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_temporal_spatial_rel_ever" + }, + { + "name": "tcontains_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcontains_geo_tgeo", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tcontains_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcontains_tgeo_geo", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tcontains_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcontains_tgeo_tgeo", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tcovers_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcovers_geo_tgeo", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tcovers_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcovers_tgeo_geo", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tcovers_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcovers_tgeo_tgeo", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdisjoint_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdisjoint_geo_tgeo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdisjoint_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdisjoint_tgeo_geo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdisjoint_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdisjoint_tgeo_tgeo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdwithin_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tdwithin_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tgeo_geo", + "sqlfn": "tDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdwithin_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tgeo_tgeo", + "sqlfn": "tDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_temp" + }, + { + "name": "tintersects_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tintersects_geo_tgeo", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tintersects_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tintersects_tgeo_geo", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tintersects_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tintersects_tgeo_tgeo", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "ttouches_geo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttouches_geo_tgeo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "ttouches_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ttouches_tgeo_geo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "ttouches_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttouches_tgeo_tgeo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_temp" + }, + { + "name": "tdistance_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdistance_tgeo_geo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_geo_distance" + }, + { + "name": "tdistance_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdistance_tgeo_tgeo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_geo_distance" + }, + { + "name": "nad_stbox_geo", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAD_stbox_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "nad_stbox_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_stbox_stbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "nad_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAD_tgeo_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "nad_tgeo_stbox", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_tgeo_stbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "nad_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tgeo_tgeo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "nai_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAI_tgeo_geo", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_distance" + }, + { + "name": "nai_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAI_tgeo_tgeo", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_distance" + }, + { + "name": "shortestline_tgeo_geo", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Shortestline_tgeo_geo", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_distance" + }, + { + "name": "shortestline_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Shortestline_tgeo_tgeo", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_distance" + }, + { + "name": "mindistance_tgeoarr_tgeoarr", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "arr1", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "arr2", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Mindistance_tgeoarr_tgeoarr", + "sqlfn": "minDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_distance" + }, + { + "name": "mindistance_tgeo_tgeo", + "file": "meos_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "threshold", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "NAD_tgeo_tgeo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_geo_distance" + }, + { + "name": "edwithin_tgeoarr_tgeoarr", + "file": "meos_geo.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "arr1", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "arr2", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Edwithin_tgeoarr_tgeoarr", + "sqlfn": "eDwithinPairs", + "sqlArity": 5, + "sqlArityMax": 5, + "group": "meos_geo_rel_ever" + }, + { + "name": "tdwithin_tgeoarr_tgeoarr", + "file": "meos_geo.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "arr1", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "arr2", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "periods", + "cType": "SpanSet ***", + "canonical": "struct SpanSet ***" + } + ], + "mdbC": "Tdwithin_tgeoarr_tgeoarr", + "sqlfn": "tDwithinPairs", + "sqlArity": 6, + "sqlArityMax": 6, + "group": "meos_geo_rel_temp" + }, + { + "name": "adisjoint_tgeoarr_tgeoarr", + "file": "meos_geo.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "arr1", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "arr2", + "cType": "const Temporal **", + "canonical": "const Temporal **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Adisjoint_tgeoarr_tgeoarr", + "sqlfn": "aDisjointPairs", + "sqlArity": 4, + "sqlArityMax": 4, + "group": "meos_geo_rel_ever" + }, + { + "name": "tpoint_tcentroid_finalfn", + "file": "meos_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "mdbC": "Tpoint_tcentroid_finalfn", + "sqlfn": "tCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_geo_agg" + }, + { + "name": "tpoint_tcentroid_transfn", + "file": "meos_geo.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpoint_tcentroid_transfn", + "sqlfn": "tCentroid", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_agg" + }, + { + "name": "tspatial_extent_transfn", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tspatial_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_agg" + }, + { + "name": "stbox_get_space_tile", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_geo_tile" + }, + { + "name": "stbox_get_space_time_tile", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_geo_tile" + }, + { + "name": "stbox_get_time_tile", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_geo_tile" + }, + { + "name": "stbox_space_tiles", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "bounds", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Stbox_space_tiles", + "sqlfn": "spaceTiles", + "sqlArity": 4, + "sqlArityMax": 6, + "group": "meos_geo_tile" + }, + { + "name": "stbox_space_time_tiles", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "bounds", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Stbox_space_time_tiles", + "sqlfn": "spaceTimeTiles", + "sqlArity": 5, + "sqlArityMax": 8, + "group": "meos_geo_tile" + }, + { + "name": "stbox_time_tiles", + "file": "meos_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "bounds", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Stbox_time_tiles", + "sqlfn": "timeTiles", + "sqlArity": 2, + "sqlArityMax": 5, + "group": "meos_geo_tile" + }, + { + "name": "tgeo_space_split", + "file": "meos_geo.h", + "returnType": { + "c": "SpaceSplit", + "canonical": "struct SpaceSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_space_split", + "sqlfn": "spaceSplit", + "sqlArity": 4, + "sqlArityMax": 7, + "group": "meos_geo_tile" + }, + { + "name": "tgeo_space_time_split", + "file": "meos_geo.h", + "returnType": { + "c": "SpaceTimeSplit", + "canonical": "struct SpaceTimeSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_space_time_split", + "sqlfn": "spaceTimeSplit", + "sqlArity": 5, + "sqlArityMax": 9, + "group": "meos_geo_tile" + }, + { + "name": "geo_cluster_kmeans", + "file": "meos_geo.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "geoms", + "cType": "const GSERIALIZED **", + "canonical": "const GSERIALIZED **" + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "k", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_cluster_dbscan", + "file": "meos_geo.h", + "returnType": { + "c": "uint32_t *", + "canonical": "unsigned int *" + }, + "params": [ + { + "name": "geoms", + "cType": "const GSERIALIZED **", + "canonical": "const GSERIALIZED **" + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + }, + { + "name": "minpoints", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_cluster_intersecting", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "geoms", + "cType": "const GSERIALIZED **", + "canonical": "const GSERIALIZED **" + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_cluster_within", + "file": "meos_geo.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "geoms", + "cType": "const GSERIALIZED **", + "canonical": "const GSERIALIZED **" + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "tolerance", + "cType": "double", + "canonical": "double" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_geo_base_spatial" + }, + { + "name": "geo_wlof", + "file": "meos_geo.h", + "returnType": { + "c": "double *", + "canonical": "double *" + }, + "params": [ + { + "name": "geoms", + "cType": "const GSERIALIZED **", + "canonical": "const GSERIALIZED **" + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "k", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "epsilon", + "cType": "double", + "canonical": "double" + }, + { + "name": "newcount", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "clusters", + "cType": "GSERIALIZED ***", + "canonical": "GSERIALIZED ***" + } + ], + "group": "meos_temporal_analytics_outlier" + }, + { + "name": "cbuffer_as_ewkt", + "file": "meos_cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Cbuffer_as_ewkt", + "sqlfn": "asEWKT", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_as_hexwkb", + "file": "meos_cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Cbuffer_as_hexwkb", + "sqlfn": "asHexWKB", + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_as_text", + "file": "meos_cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Cbuffer_as_text", + "sqlfn": "asText", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_as_wkb", + "file": "meos_cbuffer.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "size_t *" + } + ], + "mdbC": "Cbuffer_recv", + "sqlfn": "cbuffer_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_from_hexwkb", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Cbuffer_from_hexwkb", + "sqlfn": "cbufferFromHexWKB", + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_from_wkb", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "size_t" + } + ], + "mdbC": "Cbuffer_recv", + "sqlfn": "cbuffer_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_in", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Cbuffer_in", + "sqlfn": "cbuffer_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_out", + "file": "meos_cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Cbuffer_out", + "sqlfn": "cbuffer_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_inout" + }, + { + "name": "cbuffer_copy", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_cbuffer_base_constructor" + }, + { + "name": "cbuffer_make", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "radius", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Cbuffer_constructor", + "sqlfn": "cbuffer", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_constructor" + }, + { + "name": "cbuffer_to_geom", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_to_geom", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_base_conversion" + }, + { + "name": "cbuffer_to_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_base_conversion" + }, + { + "name": "cbufferarr_to_geom", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "cbarr", + "cType": "const Cbuffer **", + "canonical": "const struct Cbuffer **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_cbuffer_base_conversion" + }, + { + "name": "geom_to_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geom_to_cbuffer", + "sqlfn": "cbuffer", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_base_conversion" + }, + { + "name": "cbuffer_hash", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_cbuffer_base_accessor" + }, + { + "name": "cbuffer_hash_extended", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_cbuffer_base_accessor" + }, + { + "name": "cbuffer_point", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_point", + "sqlfn": "point", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_accessor" + }, + { + "name": "cbuffer_radius", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_radius", + "sqlfn": "radius", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_accessor" + }, + { + "name": "cbuffer_round", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_cbuffer_base_transf" + }, + { + "name": "cbufferarr_round", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer **", + "canonical": "struct Cbuffer **" + }, + "params": [ + { + "name": "cbarr", + "cType": "const Cbuffer **", + "canonical": "const struct Cbuffer **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Cbufferarr_round", + "sqlfn": "round", + "group": "meos_cbuffer_base_transf" + }, + { + "name": "cbuffer_set_srid", + "file": "meos_cbuffer.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cb", + "cType": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Cbuffer_set_srid", + "sqlfn": "setSRID", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_srid" + }, + { + "name": "cbuffer_srid", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_base_srid" + }, + { + "name": "cbuffer_transform", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_cbuffer_base_srid" + }, + { + "name": "cbuffer_transform_pipeline", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "pipelinestr", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_cbuffer_base_srid" + }, + { + "name": "contains_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_contains", + "sqlfn": "cbuffer_contains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "covers_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_covers", + "sqlfn": "cbuffer_covers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "disjoint_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_intersects", + "sqlfn": "cbuffer_intersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "dwithin_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Cbuffer_dwithin", + "sqlfn": "cbuffer_dwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "intersects_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_intersects", + "sqlfn": "cbuffer_intersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "touches_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_touches", + "sqlfn": "cbuffer_touches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_rel" + }, + { + "name": "cbuffer_tstzspan_to_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Cbuffer_tstzspan_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_box" + }, + { + "name": "cbuffer_timestamptz_to_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Cbuffer_timestamptz_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_box" + }, + { + "name": "distance_cbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Distance_cbuffer_cbuffer", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_base_dist" + }, + { + "name": "distance_cbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Distance_cbuffer_geo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_base_dist" + }, + { + "name": "distance_cbuffer_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Distance_cbuffer_stbox", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_base_dist" + }, + { + "name": "nad_cbuffer_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_cbuffer_stbox", + "sqlfn": "tDistance", + "sqlop": "<->", + "group": "meos_cbuffer_base_dist" + }, + { + "name": "cbuffer_cmp", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_cmp", + "sqlfn": "cbuffer_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_eq", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_eq", + "sqlfn": "cbuffer_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_ge", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_ge", + "sqlfn": "cbuffer_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_gt", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_gt", + "sqlfn": "cbuffer_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_le", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_le", + "sqlfn": "cbuffer_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_lt", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_lt", + "sqlfn": "cbuffer_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_ne", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_ne", + "sqlfn": "cbuffer_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_nsame", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbuffer_same", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_cbuffer_base_comp" + }, + { + "name": "cbufferset_in", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_inout" + }, + { + "name": "cbufferset_out", + "file": "meos_cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_inout" + }, + { + "name": "cbufferset_make", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Cbuffer **", + "canonical": "struct Cbuffer **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_constructor" + }, + { + "name": "cbuffer_to_set", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_conversion" + }, + { + "name": "cbufferset_end_value", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_accessor" + }, + { + "name": "cbufferset_start_value", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_accessor" + }, + { + "name": "cbufferset_value_n", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Cbuffer **", + "canonical": "struct Cbuffer **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_set_accessor" + }, + { + "name": "cbufferset_values", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer **", + "canonical": "struct Cbuffer **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_set_accessor" + }, + { + "name": "cbuffer_union_transfn", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_cbuffer_set_setops" + }, + { + "name": "contained_cbuffer_set", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "contains_set_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "cb", + "cType": "Cbuffer *", + "canonical": "struct Cbuffer *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "intersection_cbuffer_set", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "intersection_set_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "minus_cbuffer_set", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "minus_set_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "union_cbuffer_set", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "union_set_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_cbuffer_set_setops" + }, + { + "name": "tcbuffer_in", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_cbuffer_inout" + }, + { + "name": "tcbuffer_from_mfjson", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_cbuffer_inout" + }, + { + "name": "tcbufferinst_make", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbuffer_make", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tpoint", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tfloat", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_constructor", + "sqlfn": "tcbuffer_constructor", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbuffer_from_base_temp", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbufferseq_from_base_tstzset", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbufferseq_from_base_tstzspan", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbufferseqset_from_base_tstzspanset", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_cbuffer_constructor" + }, + { + "name": "tcbuffer_end_value", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_points", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_points", + "sqlfn": "points", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_radius", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_points", + "sqlfn": "points", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_traversed_area", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_cbuffer_spatial_accessor" + }, + { + "name": "tcbuffer_convex_hull", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_convex_hull", + "sqlfn": "convexHull", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_start_value", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_value_at_timestamptz", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Cbuffer **", + "canonical": "struct Cbuffer **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_value_n", + "file": "meos_cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Cbuffer **", + "canonical": "struct Cbuffer **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_values", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Cbuffer **", + "canonical": "struct Cbuffer **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_cbuffer_accessor" + }, + { + "name": "tcbuffer_to_tfloat", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_to_tfloat", + "sqlfn": "tfloat", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_conversion" + }, + { + "name": "tcbuffer_to_tgeompoint", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcbuffer_to_tgeompoint", + "sqlfn": "tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_conversion" + }, + { + "name": "tgeometry_to_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeometry_to_tcbuffer", + "sqlfn": "tcbuffer", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_cbuffer_conversion" + }, + { + "name": "tcbuffer_expand", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tcbuffer_expand", + "sqlfn": "expand", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_transf" + }, + { + "name": "tcbuffer_at_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tcbuffer_at_geom", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcbuffer_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tcbuffer_at_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_at_stbox", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tcbuffer_minus_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tcbuffer_minus_geom", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcbuffer_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tcbuffer_minus_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_minus_stbox", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_cbuffer_restrict" + }, + { + "name": "tdistance_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tdistance_tcbuffer_cbuffer", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_dist" + }, + { + "name": "tdistance_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdistance_tcbuffer_geo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_dist" + }, + { + "name": "tdistance_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdistance_tcbuffer_tcbuffer", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_cbuffer_dist" + }, + { + "name": "nad_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "NAD_tcbuffer_cbuffer", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "nad_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAD_tcbuffer_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "nad_tcbuffer_stbox", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_tcbuffer_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "nad_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tcbuffer_tcbuffer", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "mindistance_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "threshold", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_cbuffer_dist" + }, + { + "name": "nai_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "NAI_tcbuffer_cbuffer", + "sqlfn": "nearestApproachInstant", + "group": "meos_cbuffer_dist" + }, + { + "name": "nai_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAI_tcbuffer_geo", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "nai_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAI_tcbuffer_tcbuffer", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "shortestline_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Shortestline_tcbuffer_cbuffer", + "sqlfn": "shortestLine", + "group": "meos_cbuffer_dist" + }, + { + "name": "shortestline_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Shortestline_tcbuffer_geo", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "shortestline_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Shortestline_tcbuffer_tcbuffer", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "always_eq_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_cbuffer_tcbuffer", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "always_eq_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Always_eq_tcbuffer_cbuffer", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "always_eq_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_tcbuffer_tcbuffer", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "always_ne_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_cbuffer_tcbuffer", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "always_ne_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Always_ne_tcbuffer_cbuffer", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "always_ne_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_tcbuffer_tcbuffer", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_eq_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_cbuffer_tcbuffer", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_eq_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Ever_eq_tcbuffer_cbuffer", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_eq_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_tcbuffer_tcbuffer", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_ne_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_cbuffer_tcbuffer", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_ne_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Ever_ne_tcbuffer_cbuffer", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "ever_ne_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_tcbuffer_tcbuffer", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_cbuffer_comp_ever" + }, + { + "name": "teq_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_cbuffer_tcbuffer", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_cbuffer_comp_temp" + }, + { + "name": "teq_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Teq_tcbuffer_cbuffer", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_cbuffer_comp_temp" + }, + { + "name": "tne_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_cbuffer_tcbuffer", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_cbuffer_comp_temp" + }, + { + "name": "tne_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tne_tcbuffer_cbuffer", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_cbuffer_comp_temp" + }, + { + "name": "acontains_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_cbuffer_tcbuffer", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acontains_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_geo_tcbuffer", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acontains_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Acontains_tcbuffer_cbuffer", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acontains_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Acontains_tcbuffer_geo", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acovers_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acovers_cbuffer_tcbuffer", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acovers_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acovers_geo_tcbuffer", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acovers_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Acovers_tcbuffer_cbuffer", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "acovers_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Acovers_tcbuffer_geo", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "acovers_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acovers_tcbuffer_tcbuffer", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "adisjoint_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Adisjoint_tcbuffer_geo", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "adisjoint_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Adisjoint_tcbuffer_geo", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "adisjoint_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adisjoint_tcbuffer_tcbuffer", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "adwithin_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_tcbuffer_geo", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "adwithin_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_tcbuffer_cbuffer", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "adwithin_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_tcbuffer_tcbuffer", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "aintersects_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Aintersects_tcbuffer_geo", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "aintersects_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Aintersects_tcbuffer_cbuffer", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "aintersects_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Aintersects_tcbuffer_tcbuffer", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "atouches_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_tcbuffer_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "atouches_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Atouches_tcbuffer_cbuffer", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "atouches_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Atouches_tcbuffer_tcbuffer", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "econtains_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Econtains_cbuffer_tcbuffer", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "econtains_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Econtains_tcbuffer_cbuffer", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "econtains_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Econtains_tcbuffer_geo", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "ecovers_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_cbuffer_tcbuffer", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "ecovers_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_geo_tcbuffer", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "ecovers_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Ecovers_tcbuffer_cbuffer", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "ecovers_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ecovers_tcbuffer_geo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "ecovers_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_tcbuffer_tcbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "edisjoint_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Edisjoint_tcbuffer_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "edisjoint_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Edisjoint_tcbuffer_cbuffer", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "edwithin_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_tcbuffer_geo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "edwithin_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_tcbuffer_cbuffer", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "edwithin_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_tcbuffer_tcbuffer", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "eintersects_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Eintersects_tcbuffer_geo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "eintersects_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Eintersects_tcbuffer_cbuffer", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "eintersects_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Eintersects_tcbuffer_tcbuffer", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "etouches_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_tcbuffer_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "etouches_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Atouches_tcbuffer_cbuffer", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_ever" + }, + { + "name": "etouches_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Etouches_tcbuffer_tcbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_geo_rel_ever" + }, + { + "name": "tcontains_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcontains_cbuffer_tcbuffer", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcontains_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcontains_geo_tcbuffer", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcontains_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcontains_geo_tcbuffer", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcontains_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tcontains_cbuffer_tcbuffer", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcontains_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcontains_tcbuffer_tcbuffer", + "sqlfn": "tContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcovers_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcovers_cbuffer_tcbuffer", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcovers_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcovers_geo_tcbuffer", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcovers_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tcovers_tcbuffer_geo", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcovers_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tcovers_cbuffer_tcbuffer", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tcovers_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tcovers_tcbuffer_tcbuffer", + "sqlfn": "tCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdwithin_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tcbuffer_geo", + "sqlfn": "tTouches", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdwithin_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tcbuffer_geo", + "sqlfn": "tTouches", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdwithin_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tcbuffer_cbuffer", + "sqlfn": "tDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdwithin_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tdwithin_tcbuffer_tcbuffer", + "sqlfn": "tDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdisjoint_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdisjoint_tcbuffer_geo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdisjoint_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdisjoint_tcbuffer_geo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdisjoint_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdisjoint_tcbuffer_geo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdisjoint_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tdisjoint_tcbuffer_geo", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tdisjoint_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdisjoint_tcbuffer_tcbuffer", + "sqlfn": "tDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tintersects_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tintersects_cbuffer_tcbuffer", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tintersects_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tintersects_tcbuffer_geo", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tintersects_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tintersects_tcbuffer_geo", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tintersects_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Tintersects_tcbuffer_cbuffer", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "tintersects_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tintersects_tcbuffer_tcbuffer", + "sqlfn": "tIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ttouches_geo_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttouches_tcbuffer_geo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ttouches_tcbuffer_geo", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ttouches_tcbuffer_geo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ttouches_cbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttouches_cbuffer_tcbuffer", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ttouches_tcbuffer_cbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Ttouches_cbuffer_tcbuffer", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ttouches_tcbuffer_tcbuffer", + "file": "meos_cbuffer.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttouches_tcbuffer_geo", + "sqlfn": "tTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_rel_temp" + }, + { + "name": "ensure_valid_cbuffer_cbuffer", + "file": "cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ] + }, + { + "name": "ensure_valid_cbuffer_geo", + "file": "cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_cbuffer_stbox", + "file": "cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_cbufferset_cbuffer", + "file": "cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ] + }, + { + "name": "cbuffer_collinear", + "file": "cbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cbuf3", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "cbuffersegm_interpolate", + "file": "cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "start", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "end", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "cbuffersegm_locate", + "file": "cbuffer.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "start", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "end", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "value", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ] + }, + { + "name": "cbuffer_parse", + "file": "cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "cbuffer_wkt_out", + "file": "cbuffer.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "extended", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "cbuffer_point_p", + "file": "cbuffer.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_point", + "sqlfn": "point", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_base_accessor" + }, + { + "name": "datum_cbuffer_round", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "buffer", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "Datum" + } + ] + }, + { + "name": "cbuffer_transf_pj", + "file": "cbuffer.h", + "returnType": { + "c": "Cbuffer *", + "canonical": "struct Cbuffer *" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "srid_to", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "pj", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "cbuffer_distance", + "file": "cbuffer.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "group": "meos_internal_cbuffer_dist" + }, + { + "name": "datum_cbuffer_distance", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_dist" + }, + { + "name": "cbuffersegm_distance_turnpt", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "end1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "start2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "end2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "cbuffer_contains", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_contains", + "sqlfn": "cbuffer_contains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "cbuffer_covers", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_covers", + "sqlfn": "cbuffer_covers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "cbuffer_disjoint", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_disjoint", + "sqlfn": "cbuffer_disjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "cbuffer_intersects", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_intersects", + "sqlfn": "cbuffer_intersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "cbuffer_dwithin", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "cbuffer_touches", + "file": "cbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb1", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "cb2", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ], + "mdbC": "Cbuffer_touches", + "sqlfn": "cbuffer_touches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_contains", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_covers", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_disjoint", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_intersects", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_dwithin", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "datum_cbuffer_touches", + "file": "cbuffer.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cb1", + "cType": "Datum", + "canonical": "Datum" + }, + { + "name": "cb2", + "cType": "Datum", + "canonical": "Datum" + } + ], + "group": "meos_internal_cbuffer_base_rel" + }, + { + "name": "temptype_subtype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "subtype", + "cType": "tempSubtype", + "canonical": "tempSubtype" + } + ] + }, + { + "name": "temptype_subtype_all", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "subtype", + "cType": "tempSubtype", + "canonical": "tempSubtype" + } + ] + }, + { + "name": "tempsubtype_name", + "file": "meos_catalog.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "subtype", + "cType": "tempSubtype", + "canonical": "tempSubtype" + } + ] + }, + { + "name": "tempsubtype_from_string", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "subtype", + "cType": "int16 *", + "canonical": "short *" + } + ] + }, + { + "name": "meosoper_name", + "file": "meos_catalog.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "oper", + "cType": "MeosOper", + "canonical": "MeosOper" + } + ] + }, + { + "name": "meosoper_from_string", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosOper", + "canonical": "MeosOper" + }, + "params": [ + { + "name": "name", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "interptype_name", + "file": "meos_catalog.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "interptype_from_string", + "file": "meos_catalog.h", + "returnType": { + "c": "interpType", + "canonical": "interpType" + }, + "params": [ + { + "name": "interp_str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "meos_typeof_hexwkb", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_setspan_inout" + }, + { + "name": "meostype_name", + "file": "meos_catalog.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temptype_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "settype_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spantype_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spantype_spansettype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spansettype_spantype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "basetype_spantype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "basetype_settype", + "file": "meos_catalog.h", + "returnType": { + "c": "MeosType", + "canonical": "MeosType" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tnumber_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "geo_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "meos_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "alphanum_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "alphanum_temptype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "time_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "set_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "set_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "numset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_numset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "timeset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "set_spantype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_set_spantype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "alphanumset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "settype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "geoset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_geoset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spatialset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_spatialset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_canon_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "type_span_bbox", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_tbox_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_span_tbox_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "numspan_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "numspan_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_numspan_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "timespan_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "timespan_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spanset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "timespanset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_timespanset_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temporal_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temporal_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temptype_supports_linear", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "basetype_byvalue", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "basetype_varlength", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "meostype_length", + "file": "meos_catalog.h", + "returnType": { + "c": "int16", + "canonical": "short" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "talphanum_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "talpha_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tnumber_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tnumber_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tnumber_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tnumber_spantype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spatial_basetype", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tspatial_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tspatial_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tpoint_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tpoint_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tgeo_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tgeo_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tgeo_type_all", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tgeo_type_all", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tgeometry_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tgeometry_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tgeodetic_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tgeodetic_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_tnumber_tpoint_type", + "file": "meos_catalog.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "gsl_get_generation_rng", + "file": "meos_internal.h", + "returnType": { + "c": "gsl_rng *", + "canonical": "gsl_rng *" + }, + "params": [] + }, + { + "name": "gsl_get_aggregation_rng", + "file": "meos_internal.h", + "returnType": { + "c": "gsl_rng *", + "canonical": "gsl_rng *" + }, + "params": [] + }, + { + "name": "datum_ceil", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_degrees", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "normalize", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_float_round", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_floor", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_hash", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_hash_extended", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "datum_radians", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "floatspan_round_set", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "set_in", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_inout" + }, + { + "name": "set_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_inout" + }, + { + "name": "span_in", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_inout" + }, + { + "name": "span_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_setspan_inout" + }, + { + "name": "spanset_in", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_inout" + }, + { + "name": "spanset_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Spanset_out", + "sqlfn": "spanset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_inout" + }, + { + "name": "set_make", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "order", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "set_make_exp", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "order", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "set_make_free", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "order", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "span_make", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "lower", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "upper", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "span_set", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "lower", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "upper", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "spanset_make_exp", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "spans", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "order", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "spanset_make_free", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "spans", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "order", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_constructor" + }, + { + "name": "set_span", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_span", + "sqlfn": "span", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_conversion" + }, + { + "name": "set_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_spanset", + "sqlfn": "intspanset", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_conversion" + }, + { + "name": "value_set_span", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "value_set", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "value_span", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "numspan_width", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Numspan_width", + "sqlfn": "width", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "numspanset_width", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_width", + "sqlfn": "width", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_end_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_mem_size", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_mem_size", + "sqlfn": "memSize", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_set_subspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "minidx", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxidx", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "set_set_span", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "set_start_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_value_n", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_vals", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "set_values", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "spanset_lower", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_lower", + "sqlfn": "lower", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "spanset_mem_size", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_mem_size", + "sqlfn": "memSize", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "spanset_sps", + "file": "meos_internal.h", + "returnType": { + "c": "const Span **", + "canonical": "const struct Span **" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_setspan_accessor" + }, + { + "name": "spanset_upper", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Spanset_upper", + "sqlfn": "upper", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_setspan_accessor" + }, + { + "name": "bigintspan_set_floatspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "bigintspan_set_intspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "datespan_set_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "floatspan_set_bigintspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "floatspan_set_intspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "intspan_set_bigintspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "intspan_set_floatspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "numset_shift_scale", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "numspan_expand", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "mdbC": "Numspan_expand", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_setspan_transf" + }, + { + "name": "numspan_shift_scale", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "numspanset_shift_scale", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Numspanset_shift", + "sqlfn": "shift", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_setspan_transf" + }, + { + "name": "set_compact", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "span_expand", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "spanset_compact", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_transf" + }, + { + "name": "tbox_expand_value", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetyp", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "mdbC": "Tbox_expand_value", + "sqlfn": "expandValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_box_transf" + }, + { + "name": "textcat_textset_text_common", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tstzspan_set_datespan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_conversion" + }, + { + "name": "adjacent_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "adjacent_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "adjacent_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contained_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contained_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contained_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contains_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contains_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "contains_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "ovadj_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_topo" + }, + { + "name": "left_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "left_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "left_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "left_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "left_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "left_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "lfnadj_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overleft_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "overright_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "right_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_pos" + }, + { + "name": "bbox_type", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "bboxtype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "bbox_get_size", + "file": "meos_internal.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "bboxtype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "bbox_max_dims", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "bboxtype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temporal_bbox_eq", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "box2", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temporal_bbox_cmp", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "box2", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "bbox_union_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "inter_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "intersection_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "mi_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "minus_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_value_set", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_value_span", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "union_value_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "group": "meos_internal_setspan_set" + }, + { + "name": "distance_set_set", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Distance_set_set", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_set_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_span_span", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_span_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_span_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_spanset_span", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_spanset_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Distance_spanset_span", + "sqlfn": "distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_spanset_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_setspan_dist" + }, + { + "name": "distance_value_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_dist" + }, + { + "name": "spanbase_extent_transfn", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "state", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_agg" + }, + { + "name": "value_union_transfn", + "file": "meos_internal.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_setspan_agg" + }, + { + "name": "number_tstzspan_to_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Number_tstzspan_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_box_constructor" + }, + { + "name": "number_timestamptz_to_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Number_timestamptz_to_tbox", + "sqlfn": "tbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_box_constructor" + }, + { + "name": "tbox_set", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "p", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "float_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "int_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "number_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "number_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "mdbC": "Number_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "numset_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "numspan_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "timestamptz_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tstzset_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tstzspan_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tbox_shift_scale_value", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_box_transf" + }, + { + "name": "tbox_expand", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_transf" + }, + { + "name": "inter_tbox_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_box_set" + }, + { + "name": "tboolinst_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tboolinst_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tboolseq_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tboolseq_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tboolseqset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tboolseqset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "temporal_in", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "temporal_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "temparr_out", + "file": "meos_internal.h", + "returnType": { + "c": "char **", + "canonical": "char **" + }, + "params": [ + { + "name": "temparr", + "cType": "Temporal **", + "canonical": "Temporal **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatinst_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatinst_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatseq_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatseq_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatseqset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tfloatseqset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tinstant_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "spatial", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tinstant_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tinstant_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tbigintinst_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tbigintinst_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tbigintseq_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tbigintseqset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tbigintseqset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintinst_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintinst_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintseq_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintseq_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintseqset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "tintseqset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequence_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "spatial", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequence_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequence_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequenceset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "spatial", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequenceset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "tsequenceset_out", + "file": "meos_internal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextinst_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextinst_in", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextseq_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextseq_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextseqset_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "ttextseqset_in", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_temporal_inout" + }, + { + "name": "temporal_from_mfjson", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_inout" + }, + { + "name": "temporal_from_base_temp", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tinstant_copy", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tinstant_make", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tinstant_make_free", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ] + }, + { + "name": "tsequence_copy", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequence_from_base_temp", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tsequence_from_base_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tsequence_from_base_tstzset", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequence_from_base_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequence_make_exp", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequence_make_free", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequenceset_copy", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tseqsetarr_to_tseqset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seqsets", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "totalseqs", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tsequenceset_from_base_temp", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "tsequenceset_from_base_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequenceset_make_exp", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "tsequenceset_make_free", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_constructor" + }, + { + "name": "temporal_set_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_set_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumber_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tnumberinst_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tnumberseq_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tnumberseqset_set_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tsequence_set_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_set_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_end_inst", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_end_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_inst_n", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_insts_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant **", + "canonical": "const struct TInstant **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_max_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_instant", + "sqlfn": "maxInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_temporal_accessor" + }, + { + "name": "temporal_max_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_mem_size", + "file": "meos_internal.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_mem_size", + "sqlfn": "memSize", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_min_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_min_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_sequences_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TSequence **", + "canonical": "const struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_sequences", + "sqlfn": "sequences", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_set_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "void *", + "canonical": "void *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_start_inst", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_start_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_values_p", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_value_n", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_values", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_hash", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_hash", + "sqlfn": "tint_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_insts", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant **", + "canonical": "const struct TInstant **" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_instants", + "sqlfn": "instants", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_set_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "result", + "cType": "void *", + "canonical": "void *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tinstant_time", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_time", + "sqlfn": "getTime", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_timestamps", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz *", + "canonical": "TimestampTz *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_timestamps", + "sqlfn": "timestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_value_p", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Tinstant_value", + "sqlfn": "getValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_value", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Tinstant_value", + "sqlfn": "getValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_value_at_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_values_p", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumber_set_span", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberinst_valuespans", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseq_avg_val", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnumberseq_valuespans", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tnumber_valuespans", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseqset_avg_val", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tnumber_avg_value", + "sqlfn": "avgValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseqset_valuespans", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tnumber_valuespans", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_duration", + "file": "meos_internal.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_end_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_end_timestamptz", + "sqlfn": "endTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_hash", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_hash", + "sqlfn": "tint_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_insts_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant **", + "canonical": "const struct TInstant **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_max_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_max_instant", + "sqlfn": "maxInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_max_val", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_min_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_min_instant", + "sqlfn": "minInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_min_val", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_segments", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_segments", + "sqlfn": "segments", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_seqs", + "file": "meos_internal.h", + "returnType": { + "c": "const TSequence **", + "canonical": "const struct TSequence **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_sequences", + "sqlfn": "sequences", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_start_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_start_timestamptz", + "sqlfn": "startTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_time", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_time", + "sqlfn": "getTime", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_timestamps", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz *", + "canonical": "TimestampTz *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_timestamps", + "sqlfn": "timestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_value_at_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequence_values_p", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_duration", + "file": "meos_internal.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "boundspan", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_duration", + "sqlfn": "duration", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_end_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_end_timestamptz", + "sqlfn": "endTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_hash", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_hash", + "sqlfn": "tint_hash", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_inst_n", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_instant_n", + "sqlfn": "instantN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_insts_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant **", + "canonical": "const struct TInstant **" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_max_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_max_instant", + "sqlfn": "maxInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_max_val", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_max_value", + "sqlfn": "maxValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_min_inst_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TInstant *", + "canonical": "const struct TInstant *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_min_instant", + "sqlfn": "minInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_min_val", + "file": "meos_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_min_value", + "sqlfn": "minValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_num_instants", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_num_instants", + "sqlfn": "numInstants", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_num_timestamps", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_num_timestamps", + "sqlfn": "numTimestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_segments", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_segments", + "sqlfn": "segments", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_sequences_p", + "file": "meos_internal.h", + "returnType": { + "c": "const TSequence **", + "canonical": "const struct TSequence **" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_start_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz", + "canonical": "TimestampTz" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_start_timestamptz", + "sqlfn": "startTimestamp", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_time", + "file": "meos_internal.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_time", + "sqlfn": "getTime", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_timestamptz_n", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Temporal_timestamptz_n", + "sqlfn": "timestampN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_timestamps", + "file": "meos_internal.h", + "returnType": { + "c": "TimestampTz *", + "canonical": "TimestampTz *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_timestamps", + "sqlfn": "timestamps", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_value_at_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_value_n", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_value_n_p", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tsequenceset_values_p", + "file": "meos_internal.h", + "returnType": { + "c": "Datum *", + "canonical": "int ((*)(int *))()" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_restart", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "temporal_tsequence", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequence", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "temporal_tsequenceset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tinstant_shift_time", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tinstant_to_tsequence", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequence", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tinstant_to_tsequence_free", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "inst", + "cType": "TInstant *", + "canonical": "struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequence", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tinstant_to_tsequenceset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tnumber_shift_scale_value", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tnumberinst_shift_value", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tnumberseq_shift_scale_value", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tnumberseqset_shift_scale_value", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_shift_value", + "sqlfn": "shiftValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_restart", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_set_interp", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_set_interp", + "sqlfn": "setInterp", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_shift_scale_time", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_subseq", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "from", + "cType": "int", + "canonical": "int" + }, + { + "name": "to", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_to_tinstant", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_to_tinstant", + "sqlfn": "tintInst", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_to_tsequenceset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_to_tsequenceset_free", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_to_tsequenceset_interp", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_to_tsequenceset", + "sqlfn": "tintSeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_restart", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_set_interp", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_set_interp", + "sqlfn": "setInterp", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_shift_scale_time", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "start", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_shift_time", + "sqlfn": "shiftTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_to_discrete", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_to_linear", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_to_step", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_to_tinstant", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_to_tinstant", + "sqlfn": "tintInst", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_to_tsequence", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_to_tsequence", + "sqlfn": "tintSeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_temporal_transf" + }, + { + "name": "tinstant_merge", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_merge", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tinstant_merge_array", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_merge_array", + "sqlfn": "merge", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_append_tinstant", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tinstant", + "sqlfn": "appendInstant", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_append_tsequence", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tsequence", + "sqlfn": "appendSequence", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_delete_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_timestamptz", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_delete_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_delete_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspan", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_delete_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspanset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_insert", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_merge", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_merge", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_merge_array", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_merge_array", + "sqlfn": "merge", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_append_tinstant", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tinstant", + "sqlfn": "appendInstant", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_append_tsequence", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tsequence", + "sqlfn": "appendSequence", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_delete_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_minus_timestamptz", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_delete_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Temporal_minus_tstzset", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_delete_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Temporal_minus_tstzspan", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_delete_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ps", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Temporal_minus_tstzspanset", + "sqlfn": "minusTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_insert", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_merge", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_merge", + "sqlfn": "merge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_merge_array", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seqsets", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_merge_array", + "sqlfn": "merge", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequence_expand_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tsequence_set_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "void *", + "canonical": "void *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tsequenceset_expand_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tsequenceset_set_bbox", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "result", + "cType": "void *", + "canonical": "void *" + } + ], + "group": "meos_internal_temporal_bbox" + }, + { + "name": "tcontseq_after_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tcontseq_before_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tcontseq_restrict_minmax", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "min", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_min", + "sqlfn": "atMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tdiscseq_after_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_before_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_restrict_minmax", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "min", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_min", + "sqlfn": "atMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_bbox_restrict_set", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_minmax", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "min", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_min", + "sqlfn": "atMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_timestamptz", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspan", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_value", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_restrict_values", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_values", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "temporal_value_at_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tinstant_after_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_after_timestamptz", + "sqlfn": "afterTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_before_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_before_timestamptz", + "sqlfn": "beforeTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "period", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspan", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspanset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_timestamptz", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_value", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_restrict_values", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_values", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumber_restrict_span", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_span", + "sqlfn": "atSpan", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumber_restrict_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_spanset", + "sqlfn": "atSpanset", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumberinst_restrict_span", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_span", + "sqlfn": "atSpan", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumberinst_restrict_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_spanset", + "sqlfn": "atSpanset", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumberseqset_restrict_span", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_span", + "sqlfn": "atSpan", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tnumberseqset_restrict_spanset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "spanset", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnumber_at_spanset", + "sqlfn": "atSpanset", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequence_at_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Temporal_at_timestamptz", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequence_restrict_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspan", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequence_restrict_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_after_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_after_timestamptz", + "sqlfn": "afterTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_before_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_before_timestamptz", + "sqlfn": "beforeTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_temporal_modif" + }, + { + "name": "tsequenceset_restrict_minmax", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "min", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_min", + "sqlfn": "atMin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_tstzspan", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspan", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_tstzspanset", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ps", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzspanset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_timestamptz", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_timestamptz", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_tstzset", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_tstzset", + "sqlfn": "atTime", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_value", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tsequenceset_restrict_values", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_values", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_restrict" + }, + { + "name": "tinstant_cmp", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_cmp", + "sqlfn": "tint_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "tinstant_eq", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Temporal_eq", + "sqlfn": "tint_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "tsequence_cmp", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_cmp", + "sqlfn": "tint_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "tsequence_eq", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_eq", + "sqlfn": "tint_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "tsequenceset_cmp", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_cmp", + "sqlfn": "tint_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "tsequenceset_eq", + "file": "meos_internal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Temporal_eq", + "sqlfn": "tint_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_comp_trad" + }, + { + "name": "always_eq_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_eq_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_ne_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_ne_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_ge_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_ge_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_gt_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_gt_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_le_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_le_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_lt_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "always_lt_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_eq_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_eq_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_ne_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_ne_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_ge_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_ge_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_gt_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_gt_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_le_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_le_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_lt_base_temporal", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "ever_lt_temporal_base", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_comp_ever" + }, + { + "name": "tnumberinst_abs", + "file": "meos_internal.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Tnumber_abs", + "sqlfn": "abs", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberinst_distance", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnumberseq_abs", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tnumber_abs", + "sqlfn": "abs", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberseq_angular_difference", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberseq_delta_value", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberseqset_abs", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tnumber_abs", + "sqlfn": "abs", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberseqset_angular_difference", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_math" + }, + { + "name": "tnumberseqset_delta_value", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_math" + }, + { + "name": "distance_span_span_double", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "nad_tbox_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tbox_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_dist" + }, + { + "name": "nad_tnumber_number", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_dist" + }, + { + "name": "nad_tnumber_tbox", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "NAD_tnumber_tbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_dist" + }, + { + "name": "nad_tnumber_tnumber", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_dist" + }, + { + "name": "tdistance_tnumber_number", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_dist" + }, + { + "name": "tnumberseq_integral", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseq_twavg", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tnumber_twavg", + "sqlfn": "twAvg", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseqset_integral", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_accessor" + }, + { + "name": "tnumberseqset_twavg", + "file": "meos_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tnumber_twavg", + "sqlfn": "twAvg", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_temporal_accessor" + }, + { + "name": "temporal_compact", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequence_compact", + "file": "meos_internal.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "tsequenceset_compact", + "file": "meos_internal.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_temporal_transf" + }, + { + "name": "temporal_skiplist_make", + "file": "meos_internal.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [] + }, + { + "name": "skiplist_make", + "file": "meos_internal.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "key_size", + "cType": "size_t", + "canonical": "int (int *)" + }, + { + "name": "value_size", + "cType": "size_t", + "canonical": "int (int *)" + }, + { + "name": "comp_fn", + "cType": "int (*)(void *, void *)", + "canonical": "int (*)(void *, void *)" + }, + { + "name": "merge_fn", + "cType": "void *(*)(void *, void *)", + "canonical": "void *(*)(void *, void *)" + } + ] + }, + { + "name": "skiplist_search", + "file": "meos_internal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "key", + "cType": "void *", + "canonical": "void *" + }, + { + "name": "value", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "skiplist_free", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ], + "group": "meos_internal_temporal_agg" + }, + { + "name": "skiplist_splice", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "keys", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "values", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "sktype", + "cType": "SkipListType", + "canonical": "SkipListType" + } + ] + }, + { + "name": "temporal_skiplist_splice", + "file": "meos_internal.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "values", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "skiplist_values", + "file": "meos_internal.h", + "returnType": { + "c": "void **", + "canonical": "void **" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ] + }, + { + "name": "skiplist_keys_values", + "file": "meos_internal.h", + "returnType": { + "c": "void **", + "canonical": "void **" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "values", + "cType": "void **", + "canonical": "void **" + } + ] + }, + { + "name": "temporal_app_tinst_transfn", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "state", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ], + "mdbC": "Temporal_app_tinst_transfn", + "sqlfn": "appendInstant", + "sqlArity": 2, + "sqlArityMax": 5, + "group": "meos_internal_temporal_agg" + }, + { + "name": "temporal_app_tseq_transfn", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "state", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Temporal_app_tseq_transfn", + "sqlfn": "appendSequence", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_agg" + }, + { + "name": "span_bins", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_setspan_bin" + }, + { + "name": "spanset_bins", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_setspan_bin" + }, + { + "name": "tnumber_value_bins", + "file": "meos_internal.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_temporal_analytics_tile" + }, + { + "name": "tnumber_value_time_boxes", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tnumber_value_time_boxes", + "sqlfn": "valueTimeBoxes", + "sqlArity": 3, + "sqlArityMax": 5 + }, + { + "name": "tnumber_value_split", + "file": "meos_internal.h", + "returnType": { + "c": "DatumSplit", + "canonical": "DatumSplit" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_temporal_tile" + }, + { + "name": "tbox_get_value_time_tile", + "file": "meos_internal.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + } + ], + "mdbC": "Tbox_get_value_time_tile", + "sqlfn": "tile", + "sqlArity": 4, + "sqlArityMax": 6, + "group": "meos_internal_temporal_analytics_tile" + }, + { + "name": "tnumber_value_time_split", + "file": "meos_internal.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "value_bins", + "cType": "Datum **", + "canonical": "int ((**)(int *))()" + }, + { + "name": "time_bins", + "cType": "TimestampTz **", + "canonical": "TimestampTz **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "double2_out", + "file": "doublen.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "d", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "double2_set", + "file": "doublen.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "double", + "canonical": "double" + }, + { + "name": "b", + "cType": "double", + "canonical": "double" + }, + { + "name": "result", + "cType": "double2 *", + "canonical": "double2 *" + } + ] + }, + { + "name": "double2_add", + "file": "doublen.h", + "returnType": { + "c": "double2 *", + "canonical": "double2 *" + }, + "params": [ + { + "name": "d1", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "d2", + "cType": "const double2 *", + "canonical": "const double2 *" + } + ] + }, + { + "name": "double2_eq", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d1", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "d2", + "cType": "const double2 *", + "canonical": "const double2 *" + } + ] + }, + { + "name": "double3_out", + "file": "doublen.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "d", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "double3_set", + "file": "doublen.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "double", + "canonical": "double" + }, + { + "name": "b", + "cType": "double", + "canonical": "double" + }, + { + "name": "c", + "cType": "double", + "canonical": "double" + }, + { + "name": "result", + "cType": "double3 *", + "canonical": "double3 *" + } + ] + }, + { + "name": "double3_add", + "file": "doublen.h", + "returnType": { + "c": "double3 *", + "canonical": "double3 *" + }, + "params": [ + { + "name": "d1", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "d2", + "cType": "const double3 *", + "canonical": "const double3 *" + } + ] + }, + { + "name": "double3_eq", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d1", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "d2", + "cType": "const double3 *", + "canonical": "const double3 *" + } + ] + }, + { + "name": "double4_out", + "file": "doublen.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "d", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "double4_set", + "file": "doublen.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "double", + "canonical": "double" + }, + { + "name": "b", + "cType": "double", + "canonical": "double" + }, + { + "name": "c", + "cType": "double", + "canonical": "double" + }, + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "result", + "cType": "double4 *", + "canonical": "double4 *" + } + ] + }, + { + "name": "double4_add", + "file": "doublen.h", + "returnType": { + "c": "double4 *", + "canonical": "double4 *" + }, + "params": [ + { + "name": "d1", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "d2", + "cType": "const double4 *", + "canonical": "const double4 *" + } + ] + }, + { + "name": "double4_eq", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d1", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "d2", + "cType": "const double4 *", + "canonical": "const double4 *" + } + ] + }, + { + "name": "double2_collinear", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "x1", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "x2", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "x3", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "double3_collinear", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "x1", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "x2", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "x3", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "double4_collinear", + "file": "doublen.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "x1", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "x2", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "x3", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "double2segm_interpolate", + "file": "doublen.h", + "returnType": { + "c": "double2 *", + "canonical": "double2 *" + }, + "params": [ + { + "name": "start", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "end", + "cType": "const double2 *", + "canonical": "const double2 *" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "double3segm_interpolate", + "file": "doublen.h", + "returnType": { + "c": "double3 *", + "canonical": "double3 *" + }, + "params": [ + { + "name": "start", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "end", + "cType": "const double3 *", + "canonical": "const double3 *" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "double4segm_interpolate", + "file": "doublen.h", + "returnType": { + "c": "double4 *", + "canonical": "double4 *" + }, + "params": [ + { + "name": "start", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "end", + "cType": "const double4 *", + "canonical": "const double4 *" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "pg_atoi", + "file": "temporal.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "size", + "cType": "int", + "canonical": "int" + }, + { + "name": "c", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "ensure_has_X", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_has_Z", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_has_T", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_has_not_Z", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_not_null", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ptr", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "ensure_one_not_null", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ptr1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "ptr2", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "ensure_one_true", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ensure_valid_interp", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "ensure_continuous", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_same_interp", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_same_continuous_interp", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_linear_interp", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_nonlinear_interp", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_common_dimension", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_temporal_isof_type", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_temporal_isof_basetype", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_temporal_isof_subtype", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "type", + "cType": "tempSubtype", + "canonical": "tempSubtype" + } + ] + }, + { + "name": "ensure_same_temporal_type", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_tnumber_numspan", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "ensure_valid_tnumber_numspanset", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ] + }, + { + "name": "ensure_valid_tnumber_tbox", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "ensure_valid_temporal_set", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "ensure_valid_temporal_temporal", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_tnumber_tnumber", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_not_negative", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "ensure_positive", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "not_negative_datum", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_not_negative_datum", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "positive_datum", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_positive_datum", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_valid_day_duration", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "positive_duration", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "ensure_positive_duration", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "temporal_bbox_ptr", + "file": "temporal.h", + "returnType": { + "c": "void *", + "canonical": "void *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "intersection_temporal_temporal", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "mode", + "cType": "SyncMode", + "canonical": "SyncMode" + }, + { + "name": "inter1", + "cType": "Temporal **", + "canonical": "Temporal **" + }, + { + "name": "inter2", + "cType": "Temporal **", + "canonical": "Temporal **" + } + ] + }, + { + "name": "mobilitydb_version", + "file": "temporal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [], + "group": "meos_misc" + }, + { + "name": "mobilitydb_full_version", + "file": "temporal.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [], + "group": "meos_misc" + }, + { + "name": "round_fn", + "file": "temporal.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "temporal_bbox_restrict_value", + "file": "temporal.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "ensure_valid_tcbuffer_cbuffer", + "file": "tcbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + } + ] + }, + { + "name": "ensure_valid_tcbuffer_geo", + "file": "tcbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tcbuffer_stbox", + "file": "tcbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_tcbuffer_tcbuffer", + "file": "tcbuffer.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "tcbuffersegm_intersection_value", + "file": "tcbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tcbuffersegm_intersection", + "file": "tcbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tcbuffersegm_dwithin_turnpt", + "file": "tcbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tcbuffersegm_distance_turnpt", + "file": "tcbuffer.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "cbuffer_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "cbufferarr_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "cbuffer_timestamptz_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "cbuffer_tstzspan_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "tcbufferinst_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tcbufferinstarr_set_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tcbufferseq_expand_stbox", + "file": "tcbuffer_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tcbufferinst_traversed_area", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "mdbC": "Tcbuffer_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_spatial_accessor" + }, + { + "name": "tcbufferseq_traversed_area", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_cbuffer_spatial_accessor" + }, + { + "name": "tcbufferseqset_traversed_area", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_spatial_accessor" + }, + { + "name": "tcbuffersegm_traversed_area", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_cbuffer_spatial_accessor" + }, + { + "name": "tcbuffer_restrict_cbuffer", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_restrict" + }, + { + "name": "tcbuffer_restrict_stbox", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_at_stbox", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_cbuffer_restrict" + }, + { + "name": "tcbuffer_restrict_geom", + "file": "tcbuffer_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tcbuffer_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_restrict" + }, + { + "name": "ea_contains_geo_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Acontains_geo_tcbuffer", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2 + }, + { + "name": "ea_contains_tcbuffer_geo", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Econtains_tcbuffer_geo", + "sqlfn": "eContains", + "sqlArity": 2, + "sqlArityMax": 2 + }, + { + "name": "ea_contains_tcbuffer_cbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_contains_cbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_geo_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Acovers_geo_tcbuffer", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2 + }, + { + "name": "ea_covers_tcbuffer_geo", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Ecovers_tcbuffer_geo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2 + }, + { + "name": "ea_covers_tcbuffer_cbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_cbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_tcbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Ecovers_tcbuffer_tcbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_disjoint_tcbuffer_geo", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tcbuffer_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_disjoint_geo_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tcbuffer_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_disjoint_tcbuffer_cbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tcbuffer_cbuffer", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_disjoint_cbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tcbuffer_cbuffer", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_disjoint_tcbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tcbuffer_tcbuffer", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_intersects_tcbuffer_geo", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tcbuffer_geo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_intersects_geo_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tcbuffer_geo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_intersects_tcbuffer_cbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tcbuffer_cbuffer", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_intersects_cbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tcbuffer_cbuffer", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_intersects_tcbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tcbuffer_tcbuffer", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_touches_tcbuffer_geo", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tcbuffer_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_touches_geo_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tcbuffer_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_touches_tcbuffer_cbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tcbuffer_cbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_touches_cbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tcbuffer_cbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "ea_touches_tcbuffer_tcbuffer", + "file": "tcbuffer_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tcbuffer_tcbuffer", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_cbuffer_rel_ever" + }, + { + "name": "tinterrel_tcbuffer_cbuffer", + "file": "tcbuffer_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cb", + "cType": "const Cbuffer *", + "canonical": "const struct Cbuffer *" + }, + { + "name": "tinter", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinterrel_tcbuffer_geo", + "file": "tcbuffer_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tinter", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "clipper2_clip_poly_poly", + "file": "clip_clipper2.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "subj", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "clip", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "op", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "clipper2_traj_poly_periods", + "file": "clip_clipper2.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "out_count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "clip_poly_poly", + "file": "geo_poly_clip.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "subj", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "clip", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "operation", + "cType": "ClipOper", + "canonical": "ClipOper" + } + ] + }, + { + "name": "lwproj_lookup", + "file": "meos_transform.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "srid_from", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "srid_to", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "pj", + "cType": "int **", + "canonical": "int **" + } + ] + }, + { + "name": "spheroid_init_from_srid", + "file": "meos_transform.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "s", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "srid_check_latlong", + "file": "meos_transform.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "srid_is_latlong", + "file": "meos_transform.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "geom_serialize", + "file": "postgis_funcs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "lwgeom", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "geog_serialize", + "file": "postgis_funcs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "lwgeom", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "meos_postgis_valid_typmod", + "file": "postgis_funcs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "gs", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "typmod", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "geo_as_wkt", + "file": "postgis_funcs.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + }, + { + "name": "extended", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "box2d_to_lwgeom", + "file": "postgis_funcs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "box", + "cType": "GBOX *", + "canonical": "GBOX *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "box3d_to_lwgeom", + "file": "postgis_funcs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "box", + "cType": "BOX3D *", + "canonical": "BOX3D *" + } + ] + }, + { + "name": "MEOS_POSTGIS2GEOS", + "file": "postgis_funcs.h", + "returnType": { + "c": "GEOSGeometry *", + "canonical": "struct GEOSGeom_t *" + }, + "params": [ + { + "name": "pglwgeom", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "MEOS_GEOS2POSTGIS", + "file": "postgis_funcs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "geom", + "cType": "GEOSGeom", + "canonical": "struct GEOSGeom_t *" + }, + { + "name": "want3d", + "cType": "char", + "canonical": "char" + } + ] + }, + { + "name": "geom_spatialrel", + "file": "postgis_funcs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "rel", + "cType": "spatialRel", + "canonical": "spatialRel" + } + ] + }, + { + "name": "lwgeom_line_interpolate_point", + "file": "postgis_funcs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "geom", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "fraction", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "repeat", + "cType": "char", + "canonical": "char" + } + ] + }, + { + "name": "point_get_coords", + "file": "stbox.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "x", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "y", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "z", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "tstzset_stbox_slice", + "file": "stbox.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "tsdatum", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tstzspanset_stbox_slice", + "file": "stbox.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "psdatum", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "stbox_index_leaf_consistent", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "stbox_gist_inner_consistent", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "stbox_index_recheck", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "stboxnode_copy", + "file": "stbox_index.h", + "returnType": { + "c": "STboxNode *", + "canonical": "struct STboxNode *" + }, + "params": [ + { + "name": "box", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + } + ] + }, + { + "name": "getQuadrant8D", + "file": "stbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "centroid", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "inBox", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "stboxnode_init", + "file": "stbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "centroid", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "nodebox", + "cType": "STboxNode *", + "canonical": "struct STboxNode *" + } + ] + }, + { + "name": "stboxnode_quadtree_next", + "file": "stbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "centroid", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "quadrant", + "cType": "int", + "canonical": "int" + }, + { + "name": "next_nodebox", + "cType": "STboxNode *", + "canonical": "struct STboxNode *" + } + ] + }, + { + "name": "stboxnode_kdtree_next", + "file": "stbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "centroid", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "node", + "cType": "int", + "canonical": "int" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "next_nodebox", + "cType": "STboxNode *", + "canonical": "struct STboxNode *" + } + ] + }, + { + "name": "overlap8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overlapKD", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "contain8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "containKD", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "left8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overLeft8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "right8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overRight8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "below8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overBelow8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "above8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overAbove8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "front8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overFront8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "back8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overBack8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "before8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overBefore8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "after8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "overAfter8D", + "file": "stbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + }, + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "distance_stbox_nodebox", + "file": "stbox_index.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "query", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "nodebox", + "cType": "const STboxNode *", + "canonical": "const struct STboxNode *" + } + ] + }, + { + "name": "tspatial_spgist_get_stbox", + "file": "stbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "mobilitydb_init", + "file": "tgeo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [] + }, + { + "name": "geo_stbox", + "file": "tgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geo_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_internal_geo_box_conversion" + }, + { + "name": "stbox_geo", + "file": "tgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "Stbox_to_geo", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_internal_geo_box_conversion" + }, + { + "name": "tcomp_geo_tgeo", + "file": "tgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + } + ] + }, + { + "name": "tcomp_tgeo_geo", + "file": "tgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + } + ] + }, + { + "name": "ensure_geoaggstate", + "file": "tgeo_aggfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "state", + "cType": "const SkipList *", + "canonical": "const struct SkipList *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ensure_geoaggstate_state", + "file": "tgeo_aggfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "state1", + "cType": "const SkipList *", + "canonical": "const struct SkipList *" + }, + { + "name": "state2", + "cType": "const SkipList *", + "canonical": "const struct SkipList *" + } + ] + }, + { + "name": "tpoint_transform_tcentroid", + "file": "tgeo_aggfuncs.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tpointinst_tcentroid_finalfn", + "file": "tgeo_aggfuncs.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "tpointseq_tcentroid_finalfn", + "file": "tgeo_aggfuncs.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "point3d_min_dist", + "file": "tgeo_distance.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "p1", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "p2", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "p3", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "p4", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "fraction", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "stbox_spatial_distance", + "file": "tgeo_distance.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "tgeompointsegm_distance_turnpt", + "file": "tgeo_distance.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "tgeogpointsegm_distance_turnpt", + "file": "tgeo_distance.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "tinstant_distance", + "file": "tgeo_distance.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "tpointseq_at_geom", + "file": "tgeo_restrict.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tpointseq_interperiods", + "file": "tgeo_restrict.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "datum_point4d", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "p", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "geopoint_cmp", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "geopoint_eq", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "geopoint_same", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "datum_point_eq", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_point_same", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_point_eq", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_point_ne", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_point_same", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_point_nsame", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "point1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_geom_centroid", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geo", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum2_geog_centroid", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geo", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "geo_extract_elements", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "geo_serialize", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "geom", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "geo_distance_fn", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "point_distance_fn", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "datum_geom_distance2d", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_distance3d", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geog_distance", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geog1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geog2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pt_distance2d", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pt_distance3d", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "spatial_flags", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int16", + "canonical": "short" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_srid_is_latlong", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "ensure_spatial_validity", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_not_geodetic", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_same_geodetic", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_same_geodetic_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_same_geodetic_tspatial_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_same_geodetic_tspatial_base", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "base", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "ensure_srid_known", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "ensure_same_srid", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "srid1", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "srid2", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "ensure_same_dimensionality", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "same_spatial_dimensionality", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_same_spatial_dimensionality", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_same_dimensionality_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "same_dimensionality_tspatial_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_same_dimensionality_tspatial_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_same_spatial_dimensionality_stbox_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_same_geodetic_stbox_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_has_Z_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_has_not_Z_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_has_M_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_has_not_M_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_not_geodetic_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_point_type", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_mline_type", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "circle_type", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_circle_type", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_not_empty", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_stbox_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tspatial_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tspatial_base", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "base", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "ensure_valid_tspatial_tspatial", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_spatial_stbox_stbox", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_tgeo_stbox", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_geo_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tgeo_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tgeo_tgeo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_tpoint_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tpoint_tpoint", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "mline_type", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "tpoint_get_coord", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "coord", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_geo_accessor" + }, + { + "name": "eacomp_tgeo_geo", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "closest_point2d_on_segment_ratio", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "p", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "A", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "B", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "closest", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "closest_point3dz_on_segment_ratio", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "p", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "A", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "B", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "closest", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "closest_point_on_segment_sphere", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "p", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "A", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "B", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "closest", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "dist", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "interpolate_point4d_spheroid", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "p1", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "p2", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "p", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "s", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "f", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "geopoint_make", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "lwcircle_make", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "radius", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "geocircle_make", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "radius", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "pointsegm_interpolate", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "pointsegm_locate", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "point", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "tgeompointsegm_intersection", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tgeogpointsegm_intersection", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "geopoint_collinear", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value3", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "lwpointarr_remove_duplicates", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int **", + "canonical": "int **" + }, + "params": [ + { + "name": "points", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "lwpointarr_make_trajectory", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "points", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "lwline_make", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "value1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "lwcoll_from_points_lines", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "points", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "lines", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "npoints", + "cType": "int", + "canonical": "int" + }, + { + "name": "nlines", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tpointseq_stops_iter", + "file": "tgeo_spatialfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "mintunits", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "datum_geom_contains", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_covers", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_disjoint2d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_disjoint3d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geog_disjoint", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geog1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geog2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_intersects2d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_intersects3d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geog_intersects", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geog1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geog2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_touches", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_dwithin2d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_dwithin3d", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geom1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geom2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geog_dwithin", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geog1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geog2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_geom_relate_pattern", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "geog1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "geog2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "p", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "geo_disjoint_fn", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "geo_disjoint_fn_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "uint8_t", + "canonical": "unsigned char" + } + ] + }, + { + "name": "geo_intersects_fn", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "geo_intersects_fn_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "uint8_t", + "canonical": "unsigned char" + } + ] + }, + { + "name": "geo_dwithin_fn", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func3", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "geo_dwithin_fn_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "datum_func3", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))())" + }, + "params": [ + { + "name": "flags1", + "cType": "int16", + "canonical": "short" + }, + { + "name": "flags2", + "cType": "uint8_t", + "canonical": "unsigned char" + } + ] + }, + { + "name": "tpointsegm_tdwithin_turnpt", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "spatialrel_geo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "varfunc", + "canonical": "int (*)(int ((*)(int *))(), ...)" + }, + { + "name": "numparam", + "cType": "int", + "canonical": "int" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "spatialrel_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "varfunc", + "canonical": "int (*)(int ((*)(int *))(), ...)" + }, + { + "name": "numparam", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "ea_contains_geo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_contains_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_contains_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_covers_geo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_covers_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_covers_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_disjoint_geo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_disjoint_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edisjoint_tgeo_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_disjoint_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tgeo_tgeo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_intersects_geo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_intersects_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tgeo_geo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_intersects_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Eintersects_tgeo_tgeo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_touches_tpoint_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tpoint_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_temporal_spatial_rel_ever" + }, + { + "name": "ea_touches_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tgeo_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_touches_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Etouches_tgeo_tgeo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_dwithin_tgeo_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edwithin_tgeo_geo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_internal_geo_rel_ever" + }, + { + "name": "ea_dwithin_tgeo_tgeo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Edwithin_tgeo_tgeo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_internal_geo_spatial_rel_ever" + }, + { + "name": "ea_spatialrel_tspatial_geo", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_spatialrel_tspatial_tspatial", + "file": "tgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tspatialrel_tspatial_base", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "base", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "varfunc", + "canonical": "int (*)(int ((*)(int *))(), ...)" + }, + { + "name": "numparam", + "cType": "int", + "canonical": "int" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tspatialrel_tspatial_tspatial", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "varfunc", + "canonical": "int (*)(int ((*)(int *))(), ...)" + }, + { + "name": "numparam", + "cType": "int", + "canonical": "int" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinterrel_tgeo_geo", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "tinter", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinterrel_tspatial_base", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "base", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tinter", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "tinterrel_tspatial_tspatial", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tinter", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdwithin_tspatial_tspatial", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "sync1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "sync2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "datum_func3", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "tpfn", + "cType": "tpfunc_temp", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int, int, int *, int *)" + } + ] + }, + { + "name": "tdwithin_add_solutions", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "solutions", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc1", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "t1", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t2", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tdwithin_tspatial_spatial", + "file": "tgeo_tempspatialrels.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "base", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dist", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "datum_func3", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "tpfn", + "cType": "tpfunc_temp", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int, int, int *, int *)" + } + ], + "mdbC": "Tdwithin_tgeo_geo", + "sqlfn": "tDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_geo_rel_temp" + }, + { + "name": "bitmatrix_make", + "file": "tgeo_tile.h", + "returnType": { + "c": "BitMatrix *", + "canonical": "BitMatrix *" + }, + "params": [ + { + "name": "count", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "ndims", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tpoint_set_tiles", + "file": "tgeo_tile.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "state", + "cType": "const STboxGridState *", + "canonical": "const struct STboxGridState *" + }, + { + "name": "bm", + "cType": "BitMatrix *", + "canonical": "BitMatrix *" + } + ] + }, + { + "name": "tpoint_at_tile", + "file": "tgeo_tile.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "stbox_tile_state_set", + "file": "tgeo_tile.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "tunits", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "hasx", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hast", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "stbox_tile_state_make", + "file": "tgeo_tile.h", + "returnType": { + "c": "STboxGridState *", + "canonical": "struct STboxGridState *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "int", + "canonical": "int" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "stbox_tile_state_next", + "file": "tgeo_tile.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "state", + "cType": "STboxGridState *", + "canonical": "struct STboxGridState *" + } + ] + }, + { + "name": "stbox_tile_state_get", + "file": "tgeo_tile.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "state", + "cType": "STboxGridState *", + "canonical": "struct STboxGridState *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tgeo_space_time_tile_init", + "file": "tgeo_tile.h", + "returnType": { + "c": "STboxGridState *", + "canonical": "struct STboxGridState *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "ntiles", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "stbox_space_time_tile", + "file": "tgeo_tile.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "hasx", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hast", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "create_trip", + "file": "tpoint_datagen.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "lines", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "maxSpeeds", + "cType": "const double *", + "canonical": "const double *" + }, + { + "name": "categories", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "noEdges", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "startTime", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "disturbData", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "verbosity", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "spatialarr_wkt_out", + "file": "tspatial.h", + "returnType": { + "c": "char **", + "canonical": "char **" + }, + "params": [ + { + "name": "spatialarr", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "extended", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "spatialbase_as_text", + "file": "tspatial.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "spatialbase_as_ewkt", + "file": "tspatial.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "point_transf_pj", + "file": "tspatial.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + { + "name": "srid_to", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "pj", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "tgeoinst_set_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeoinstarr_set_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeoseq_expand_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tspatialinst_set_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tspatialinstarr_set_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "box", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "tspatialseqarr_set_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tspatialseq_expand_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "spatialarr_set_bbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "boxop_tspatial_stbox", + "file": "tspatial_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "bool", + "cType": "int (int *)", + "canonical": "int (int *)" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boxop_tspatial_tspatial", + "file": "tspatial_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "bool", + "cType": "int (int *)", + "canonical": "int (int *)" + } + ] + }, + { + "name": "srid_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "srid", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "spatial_parse_elem", + "file": "tspatial_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "delim", + "cType": "char", + "canonical": "char" + }, + { + "name": "temp_srid", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "geo_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "delim", + "cType": "char", + "canonical": "char" + }, + { + "name": "srid", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ] + }, + { + "name": "stbox_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "tpoint_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tspatialinst_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp_srid", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tspatialseq_disc_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "temp_srid", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tspatialseq_cont_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "temp_srid", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tspatialseqset_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "temp_srid", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tspatial_parse", + "file": "tspatial_parser.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "h3_are_neighbor_cells_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "destination", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cells_to_directed_edge_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "destination", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_is_valid_directed_edge_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "edge", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_get_directed_edge_origin_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "edge", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_get_directed_edge_destination_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "edge", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_parent_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_cell_to_center_child_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_cell_to_child_pos_meos", + "file": "h3_generated.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "child", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "parentRes", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_child_pos_to_cell_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "childPos", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "parent", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "childRes", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_get_resolution_meos", + "file": "h3_generated.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "hex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_get_base_cell_number_meos", + "file": "h3_generated.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "hex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_is_valid_cell_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "hex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_is_res_class_iii_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "hex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_is_pentagon_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "hex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_get_num_cells_meos", + "file": "h3_generated.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_grid_distance_meos", + "file": "h3_generated.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "originIndex", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "h3Index", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_vertex_meos", + "file": "h3_generated.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "vertexNum", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_is_valid_vertex_meos", + "file": "h3_generated.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "vertex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3index_in", + "file": "h3index.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "H3index_in", + "sqlfn": "h3index_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_base_inout" + }, + { + "name": "h3index_out", + "file": "h3index.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "H3index_out", + "sqlfn": "h3index_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_base_inout" + }, + { + "name": "h3index_eq", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_ne", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_lt", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_le", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_gt", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_ge", + "file": "h3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_cmp", + "file": "h3index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "b", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_comp" + }, + { + "name": "h3index_hash", + "file": "h3index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "group": "meos_h3_base_accessor" + }, + { + "name": "h3_grid_disk", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "k", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_grid_ring", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "k", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_grid_path_cells", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "start", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "end", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_children", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "childRes", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_compact_cells", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cells", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "h3_uncompact_cells", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cells", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "res", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_origin_to_directed_edges", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_vertexes", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_get_icosahedron_faces", + "file": "h3index_sets.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "ensure_valid_th3index_th3index", + "file": "th3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_th3index_h3index", + "file": "th3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "ensure_valid_th3index_tgeogpoint", + "file": "th3index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "datum2_h3index_eq", + "file": "th3index.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "d2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_h3index_ne", + "file": "th3index.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "d2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "th3indexinst_set_stbox", + "file": "th3index_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "th3indexinstarr_set_stbox", + "file": "th3index_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "th3indexseq_expand_stbox", + "file": "th3index_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "h3_gs_point_to_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "point", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Geo_gs_point_to_h3index", + "sqlfn": "geoToH3Cell", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_conversion" + }, + { + "name": "h3_cell_to_gs_point", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_gs_boundary", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "cell_boundary_to_gs", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "bnd", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "h3_sample_step_deg", + "file": "th3index_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_latlng_deg_to_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "lat_deg", + "cType": "double", + "canonical": "double" + }, + { + "name": "lng_deg", + "cType": "double", + "canonical": "double" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "h3_cell_to_parent_next_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_center_child_next_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_directed_edge_to_gs_boundary", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "edge", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_vertex_to_gs_point", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "vertex", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_cell_to_local_ij_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ] + }, + { + "name": "h3_local_ij_to_cell_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "origin", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "coord", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "h3_unit_from_cstring", + "file": "th3index_internal.h", + "returnType": { + "c": "H3Unit", + "canonical": "H3Unit" + }, + "params": [ + { + "name": "unit", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "h3_cell_area_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "unit", + "cType": "H3Unit", + "canonical": "H3Unit" + } + ] + }, + { + "name": "h3_edge_length_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "edge", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "unit", + "cType": "H3Unit", + "canonical": "H3Unit" + } + ] + }, + { + "name": "h3_gs_great_circle_distance_meos", + "file": "th3index_internal.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "a", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "b", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "unit", + "cType": "H3Unit", + "canonical": "H3Unit" + } + ] + }, + { + "name": "datum_h3_get_resolution", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_get_base_cell_number", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_is_valid_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_is_res_class_iii", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_is_pentagon", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_parent", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "res_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_parent_next", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_center_child", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "res_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_center_child_next", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_child_pos", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "parent_res_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_child_pos_to_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pos_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "parent_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "child_res_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_are_neighbor_cells", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "origin_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dest_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cells_to_directed_edge", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "origin_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dest_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_is_valid_directed_edge", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_get_directed_edge_origin", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_get_directed_edge_destination", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_directed_edge_to_boundary", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_vertex", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vnum_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_vertex_to_latlng", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_is_valid_vertex", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_grid_distance", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "origin_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "dest_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_local_ij", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "origin_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_local_ij_to_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "origin_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "coord_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_latlng_to_cell", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "point_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "res_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_latlng", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_to_boundary", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_cell_area", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "cell_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "unit_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_edge_length", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "edge_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "unit_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_h3_great_circle_distance", + "file": "th3index_internal.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "a_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "b_d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "unit_d", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "json_in", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "json_out", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_from_text", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "unique_keys", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_in", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "jsonb_out", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "json_make", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "keys_vals", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "json_make_two_arg", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_copy", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_make", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "keys_vals", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_make_two_arg", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_to_bool", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_cstring", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_float4", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_float8", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_int16", + "file": "meos_json.h", + "returnType": { + "c": "int16", + "canonical": "short" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_int32", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_int64", + "file": "meos_json.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_numeric", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_to_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "json_array_element", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "element", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "json_array_element_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "element", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "json_array_elements", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_array_elements_text", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_array_length", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "json_each", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_each_text", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_extract_path", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "json_extract_path_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "json_object_field", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "json_object_field_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "json_object_keys", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_typeof", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_array_element", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "element", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_array_element_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "element", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_array_elements", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb **", + "canonical": "Jsonb **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "jsonb_array_elements_text", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "jsonb_array_length", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_contained", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_contains", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_each", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "values", + "cType": "Jsonb **", + "canonical": "Jsonb **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "jsonb_each_text", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "values", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "jsonb_exists", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_exists_array", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "keys_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "keys_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "any", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_extract_path", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_extract_path_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_hash", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_hash_extended", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_object_field", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_object_field_text", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_object_keys", + "file": "meos_json.h", + "returnType": { + "c": "text **", + "canonical": "text **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "json_strip_nulls", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "js", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "strip_in_arrays", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_concat", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_delete", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_delete_array", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "keys_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "keys_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_delete_index", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_delete_path", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "jsonb_insert", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "after", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_pretty", + "file": "meos_json.h", + "returnType": { + "c": "text *", + "canonical": "text *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "create", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_set_lax", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "create", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "handle_null", + "cType": "const text *", + "canonical": "const text *" + } + ] + }, + { + "name": "jsonb_strip_nulls", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "strip_in_arrays", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_cmp", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_eq", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_ge", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_gt", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_le", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_lt", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_ne", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb1", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jb2", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ] + }, + { + "name": "jsonb_path_exists", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_path_match", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_path_query_all", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb **", + "canonical": "Jsonb **" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_path_query_array", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonb_path_query_first", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonpath_in", + "file": "meos_json.h", + "returnType": { + "c": "JsonPath *", + "canonical": "JsonPath *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "jsonpath_copy", + "file": "meos_json.h", + "returnType": { + "c": "JsonPath *", + "canonical": "JsonPath *" + }, + "params": [ + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + } + ] + }, + { + "name": "jsonpath_out", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + } + ] + }, + { + "name": "jsonbset_in", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_inout" + }, + { + "name": "jsonbset_out", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_inout" + }, + { + "name": "jsonbset_make", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const Jsonb **", + "canonical": "const Jsonb **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_constructor" + }, + { + "name": "jsonb_to_set", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_conversion" + }, + { + "name": "jsonbset_end_value", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_accessor" + }, + { + "name": "jsonbset_start_value", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_accessor" + }, + { + "name": "jsonbset_value_n", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Jsonb **", + "canonical": "Jsonb **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_set_accessor" + }, + { + "name": "jsonbset_values", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb **", + "canonical": "Jsonb **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_accessor" + }, + { + "name": "concat_jsonbset_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_array_length", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Jsonbset_array_length", + "sqlfn": "jsonbset_array_length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_object_field", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Jsonbset_object_field", + "sqlfn": "jsonbset_object_field", + "sqlArity": 2, + "sqlArityMax": 3, + "sqlop": "->,", + "sqlfnAll": [ + "jsonbset_object_field", + "jsonbset_object_field" + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_array_element", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_delete_index", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_delete", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_delete_array", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_exists", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_exists_array", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "any", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_set", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "create", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "lax", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_to_alphanumset", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "settype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ] + }, + { + "name": "jsonbset_to_intset", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Jsonbset_to_intset", + "sqlfn": "jsonbset_to_intset", + "sqlArity": 2, + "sqlArityMax": 3, + "sqlfnAll": [ + "jsonbset_to_intset", + "tint" + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_to_floatset", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Jsonbset_to_floatset", + "sqlfn": "tfloat", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_to_textset_key", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_strip_nulls", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "strip_in_arrays", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Jsonbset_strip_nulls", + "sqlfn": "jsonbset_strip_nulls", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_pretty", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Jsonbset_pretty", + "sqlfn": "jsonbset_pretty", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_delete_path", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_extract_path", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_insert", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "after", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_path_exists", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_path_match", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_path_query_array", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "jsonbset_path_query_first", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "contained_jsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_json_set_json" + }, + { + "name": "contains_set_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "Jsonb *", + "canonical": "Jsonb *" + } + ], + "mdbC": "Concat_jsonbset_jsonb", + "sqlfn": "jsonb_concat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_json_set_json" + }, + { + "name": "intersection_jsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "intersection_set_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_json_set_json" + }, + { + "name": "jsonb_union_transfn", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "minus_jsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_json_set_json" + }, + { + "name": "minus_set_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_json_set_json" + }, + { + "name": "union_jsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_json_set_json" + }, + { + "name": "union_set_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_json_set_json" + }, + { + "name": "tjsonb_from_mfjson", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_json_inout" + }, + { + "name": "tjsonb_in", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_json_inout" + }, + { + "name": "tjsonb_out", + "file": "meos_json.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_json_inout" + }, + { + "name": "tjsonbinst_from_mfjson", + "file": "meos_json.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const json_object *", + "canonical": "const struct json_object *" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonbinst_in", + "file": "meos_json.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonbseq_from_mfjson", + "file": "meos_json.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const json_object *", + "canonical": "const struct json_object *" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonbseq_in", + "file": "meos_json.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonbseqset_from_mfjson", + "file": "meos_json.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const json_object *", + "canonical": "const struct json_object *" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonbseqset_in", + "file": "meos_json.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_json_inout" + }, + { + "name": "tjsonb_from_base_temp", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "jsonb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_json_constructor" + }, + { + "name": "tjsonbinst_make", + "file": "meos_json.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "jsonb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_constructor" + }, + { + "name": "tjsonbseq_from_base_tstzset", + "file": "meos_json.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "jsonb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tsequence_from_base_tstzset", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_constructor" + }, + { + "name": "tjsonbseq_from_base_tstzspan", + "file": "meos_json.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "jsonb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "sp", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Tsequence_from_base_tstzspan", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_json_constructor" + }, + { + "name": "tjsonbseqset_from_base_tstzspanset", + "file": "meos_json.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "jsonb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ], + "mdbC": "Tsequenceset_from_base_tstzspanset", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_json_constructor" + }, + { + "name": "tjsonb_to_ttext", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tjsonb_as_ttext", + "sqlfn": "ttext", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_json_conversion" + }, + { + "name": "ttext_to_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ttext_as_tjsonb", + "sqlfn": "tjsonb", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_json_conversion" + }, + { + "name": "tjsonb_end_value", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_accessor" + }, + { + "name": "tjsonb_start_value", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb *", + "canonical": "Jsonb *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_accessor" + }, + { + "name": "tjsonb_value_at_timestamptz", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "value", + "cType": "Jsonb **", + "canonical": "Jsonb **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_accessor" + }, + { + "name": "tjsonb_value_n", + "file": "meos_json.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Jsonb **", + "canonical": "Jsonb **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_accessor" + }, + { + "name": "tjsonb_values", + "file": "meos_json.h", + "returnType": { + "c": "Jsonb **", + "canonical": "Jsonb **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_accessor" + }, + { + "name": "concat_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Concat_tjsonb_tjsonb", + "sqlfn": "jsonb_concat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_json_json" + }, + { + "name": "concat_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Concat_tjsonb_tjsonb", + "sqlfn": "jsonb_concat", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "||", + "group": "meos_json_json" + }, + { + "name": "contains_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Contains_tjsonb_jsonb", + "sqlfn": "tjsonb_contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "@>", + "group": "meos_json_json" + }, + { + "name": "contains_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Contains_tjsonb_tjsonb", + "sqlfn": "tjsonb_contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "@>", + "group": "meos_json_json" + }, + { + "name": "null_handle_type_from_string", + "file": "meos_json.h", + "returnType": { + "c": "nullHandleType", + "canonical": "nullHandleType" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjson_array_element", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjson_array_length", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tjsonb_array_length", + "sqlfn": "tjsonb_array_length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_json" + }, + { + "name": "tjson_extract_path", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjson_object_field", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_object_field", + "sqlfn": "tjsonb_object_field", + "sqlArity": 2, + "sqlArityMax": 3, + "sqlop": "->,", + "sqlfnAll": [ + "tjsonb_object_field", + "tjsonb_object_field" + ], + "group": "meos_json_json" + }, + { + "name": "tjson_strip_nulls", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "strip_in_arrays", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tjson_strip_nulls", + "sqlfn": "tjson_strip_nulls", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_json_json" + }, + { + "name": "tjsonb_array_element", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_array_length", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tjsonb_array_length", + "sqlfn": "tjsonb_array_length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_json" + }, + { + "name": "tjsonb_delete", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_delete_array", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_delete_index", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "idx", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_delete_path", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_exists", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_exists_array", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "any", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_extract_path", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "path_elems", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_insert", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "after", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_object_field", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "astext", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_object_field", + "sqlfn": "tjsonb_object_field", + "sqlArity": 2, + "sqlArityMax": 3, + "sqlop": "->,", + "sqlfnAll": [ + "tjsonb_object_field", + "tjsonb_object_field" + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_path_exists", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_path_match", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_path_query_array", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_path_query_first", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jp", + "cType": "const JsonPath *", + "canonical": "const JsonPath *" + }, + { + "name": "vars", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "silent", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "tz", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_pretty", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tjsonb_pretty", + "sqlfn": "tjsonb_pretty", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_json_json" + }, + { + "name": "tjsonb_set", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "keys", + "cType": "text **", + "canonical": "text **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newjb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "create", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "handle_null", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "lax", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_strip_nulls", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "strip_in_arrays", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tjsonb_strip_nulls", + "sqlfn": "tjsonb_strip_nulls", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_json_json" + }, + { + "name": "tjsonb_to_tbool", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_to_tbool", + "sqlfn": "tjsonb_to_tint", + "sqlArity": 2, + "sqlArityMax": 3, + "sqlfnAll": [ + "tjsonb_to_tint", + "tbool" + ], + "group": "meos_json_json" + }, + { + "name": "tjsonb_to_tfloat", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_to_tfloat", + "sqlfn": "tfloat", + "sqlArity": 2, + "sqlArityMax": 4, + "group": "meos_json_json" + }, + { + "name": "tjsonb_to_tint", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_to_tint", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_json_json" + }, + { + "name": "tjsonb_to_ttext_key", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ], + "mdbC": "Tjsonb_to_ttext_key", + "sqlfn": "ttext", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_json_json" + }, + { + "name": "tjsonb_at_value", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jsb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_restrict" + }, + { + "name": "tjsonb_minus_value", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jsb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_json_restrict" + }, + { + "name": "always_eq_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_base_temporal", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_json_comp_ever" + }, + { + "name": "always_eq_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Always_eq_temporal_base", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_json_comp_ever" + }, + { + "name": "always_eq_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_tjsonb_tjsonb", + "sqlfn": "always_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_json_comp_ever" + }, + { + "name": "always_ne_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_base_temporal", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_json_comp_ever" + }, + { + "name": "always_ne_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Always_ne_temporal_base", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_json_comp_ever" + }, + { + "name": "always_ne_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_tjsonb_tjsonb", + "sqlfn": "always_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_eq_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_base_temporal", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_eq_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Ever_eq_temporal_base", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_eq_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_tjsonb_tjsonb", + "sqlfn": "ever_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_ne_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_base_temporal", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_ne_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Ever_ne_temporal_base", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_json_comp_ever" + }, + { + "name": "ever_ne_tjsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_tjsonb_tjsonb", + "sqlfn": "ever_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_json_comp_ever" + }, + { + "name": "teq_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_base_temporal", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_json_comp_temp" + }, + { + "name": "teq_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Teq_temporal_base", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_json_comp_temp" + }, + { + "name": "tne_jsonb_tjsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_base_temporal", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_json_comp_temp" + }, + { + "name": "tne_tjsonb_jsonb", + "file": "meos_json.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + } + ], + "mdbC": "Tne_temporal_base", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_json_comp_temp" + }, + { + "name": "setPath", + "file": "tjsonb.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "it", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "path_elems", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "path_nulls", + "cType": "bool *", + "canonical": "bool *" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "st", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "newval", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "op_type", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "setPathObject", + "file": "tjsonb.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "it", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "path_elems", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "path_nulls", + "cType": "bool *", + "canonical": "bool *" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "st", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "newval", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "npairs", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "op_type", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "setPathArray", + "file": "tjsonb.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "it", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "path_elems", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "path_nulls", + "cType": "bool *", + "canonical": "bool *" + }, + { + "name": "path_len", + "cType": "int", + "canonical": "int" + }, + { + "name": "st", + "cType": "int **", + "canonical": "int **" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "newval", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "nelems", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "op_type", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "datum_jsonb_concat", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_contained", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_contains", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_delete", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_delete_array", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "array", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_delete_index", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "idx", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_array_element", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "element", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_array_element", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "element", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_array_element_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "element", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_array_element_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "element", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_exists", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_exists_array", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "array", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "any", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_array_length", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_array_length", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_object_field", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_object_field", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_object_field_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_object_field_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_strip_nulls", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "strip_in_arrays", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_strip_nulls", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "strip_in_arrays", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_pretty", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_extract_path", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_elems", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_len", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_extract_path", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_elems", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_len", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_json_extract_path_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_elems", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_len", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_extract_path_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_elems", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "path_len", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_set", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "keys", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "newjb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "create", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_set_lax", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "keys", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "newjb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "create", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "null_handle", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_delete_path", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "keys", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_insert", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "keys", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "count", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "newjb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "after", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_path_exists", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "jp", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vars", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "silent", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tz", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_path_match", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "jp", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vars", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "silent", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tz", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_path_query_array", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "jp", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vars", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "silent", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tz", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_path_query_first", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "jp", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "vars", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "silent", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tz", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_to_text", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_text_to_jsonb", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "txt", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_jsonb_to_alphanum", + "file": "tjsonb.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "jb", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "key", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "null_handle", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "tjsonb_to_talphanum", + "file": "tjsonb.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "key", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "resbasetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "null_handle", + "cType": "nullHandleType", + "canonical": "nullHandleType" + } + ] + }, + { + "name": "jsonbfunc_jsonbset", + "file": "tjsonb.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "func", + "cType": "int", + "canonical": "int" + }, + { + "name": "intype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "restype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "jsonbfunc_jsonbset_jsonb", + "file": "tjsonb.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "jb", + "cType": "const Jsonb *", + "canonical": "const Jsonb *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "jsonbfunc_jsonbset_text", + "file": "tjsonb.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "txt", + "cType": "const text *", + "canonical": "const text *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "th3index_in", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_h3_inout" + }, + { + "name": "th3indexinst_in", + "file": "meos_h3.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_h3_inout" + }, + { + "name": "th3indexseq_in", + "file": "meos_h3.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_h3_inout" + }, + { + "name": "th3indexseqset_in", + "file": "meos_h3.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_h3_inout" + }, + { + "name": "th3index_make", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "value", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_h3_constructor" + }, + { + "name": "th3indexinst_make", + "file": "meos_h3.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "value", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_h3_constructor" + }, + { + "name": "th3indexseq_make", + "file": "meos_h3.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "values", + "cType": "const uint64_t *", + "canonical": "const uint64_t *" + }, + { + "name": "times", + "cType": "const TimestampTz *", + "canonical": "const TimestampTz *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_h3_constructor" + }, + { + "name": "th3indexseqset_make", + "file": "meos_h3.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "const TSequence **", + "canonical": "const struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_h3_constructor" + }, + { + "name": "th3index_start_value", + "file": "meos_h3.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_accessor" + }, + { + "name": "th3index_end_value", + "file": "meos_h3.h", + "returnType": { + "c": "uint64_t", + "canonical": "uint64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_accessor" + }, + { + "name": "th3index_value_n", + "file": "meos_h3.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "uint64_t *", + "canonical": "uint64_t *" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_accessor" + }, + { + "name": "th3index_values", + "file": "meos_h3.h", + "returnType": { + "c": "uint64_t *", + "canonical": "uint64_t *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_accessor" + }, + { + "name": "th3index_value_at_timestamptz", + "file": "meos_h3.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "uint64_t *", + "canonical": "uint64_t *" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_accessor" + }, + { + "name": "tbigint_to_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tbigint_to_th3index", + "sqlfn": "th3index", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_h3_conversion" + }, + { + "name": "th3index_to_tbigint", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_to_tbigint", + "sqlfn": "tbigint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_h3_conversion" + }, + { + "name": "ever_eq_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_h3index_th3index", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_h3_comp_ever" + }, + { + "name": "ever_eq_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Ever_eq_th3index_h3index", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_h3_comp_ever" + }, + { + "name": "ever_ne_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_h3index_th3index", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "ever_ne_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Ever_ne_th3index_h3index", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_eq_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_h3index_th3index", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_eq_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Always_eq_th3index_h3index", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_ne_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_h3index_th3index", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_ne_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Always_ne_th3index_h3index", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "ever_eq_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_th3index_th3index", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_h3_comp_ever" + }, + { + "name": "ever_ne_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_th3index_th3index", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_eq_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_th3index_th3index", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_h3_comp_ever" + }, + { + "name": "always_ne_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_th3index_th3index", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_h3_comp_ever" + }, + { + "name": "teq_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_h3index_th3index", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_h3_comp_temp" + }, + { + "name": "teq_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Teq_th3index_h3index", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_h3_comp_temp" + }, + { + "name": "teq_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_th3index_th3index", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_h3_comp_temp" + }, + { + "name": "tne_h3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_h3index_th3index", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_h3_comp_temp" + }, + { + "name": "tne_th3index_h3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "uint64_t", + "canonical": "uint64_t" + } + ], + "mdbC": "Tne_th3index_h3index", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_h3_comp_temp" + }, + { + "name": "tne_th3index_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_th3index_th3index", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_h3_comp_temp" + }, + { + "name": "th3index_get_resolution", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_get_resolution", + "sqlfn": "h3_get_resolution", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_inspection" + }, + { + "name": "th3index_get_base_cell_number", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_get_base_cell_number", + "sqlfn": "h3_get_base_cell_number", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_inspection" + }, + { + "name": "th3index_is_valid_cell", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_is_valid_cell", + "sqlfn": "h3_is_valid_cell", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_inspection" + }, + { + "name": "th3index_is_res_class_iii", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_is_res_class_iii", + "sqlfn": "h3_is_res_class_iii", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_inspection" + }, + { + "name": "th3index_is_pentagon", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_is_pentagon", + "sqlfn": "h3_is_pentagon", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_inspection" + }, + { + "name": "th3index_cell_to_parent", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Th3index_cell_to_parent", + "sqlfn": "h3_cell_to_parent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_hierarchy" + }, + { + "name": "th3index_cell_to_parent_next", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_parent_next", + "sqlfn": "h3_cell_to_parent", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_hierarchy" + }, + { + "name": "th3index_cell_to_center_child", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Th3index_cell_to_center_child", + "sqlfn": "h3_cell_to_center_child", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_hierarchy" + }, + { + "name": "th3index_cell_to_center_child_next", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_center_child_next", + "sqlfn": "h3_cell_to_center_child", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_hierarchy" + }, + { + "name": "th3index_cell_to_child_pos", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "parent_res", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Th3index_cell_to_child_pos", + "sqlfn": "h3_cell_to_child_pos", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_hierarchy" + }, + { + "name": "th3index_child_pos_to_cell", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "child_pos", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "parent", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "child_res", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Th3index_child_pos_to_cell", + "sqlfn": "h3_child_pos_to_cell", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_h3_hierarchy" + }, + { + "name": "tgeogpoint_to_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tgeogpoint_to_th3index", + "sqlfn": "th3index", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_latlng" + }, + { + "name": "tgeompoint_to_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tgeompoint_to_th3index", + "sqlfn": "th3index", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_latlng" + }, + { + "name": "th3index_to_tgeogpoint", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_tgeogpoint", + "sqlfn": "h3_cell_to_latlng", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_latlng" + }, + { + "name": "th3index_to_tgeompoint", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_tgeompoint", + "sqlfn": "h3_cell_to_latlng_tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_latlng" + }, + { + "name": "th3index_cell_to_boundary", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_boundary", + "sqlfn": "h3_cell_to_boundary", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_latlng" + }, + { + "name": "geo_to_h3index_set", + "file": "meos_h3.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "resolution", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Geo_to_h3indexset", + "sqlfn": "geoToH3IndexSet", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_conversion" + }, + { + "name": "ever_eq_h3indexset_th3index", + "file": "meos_h3.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "cells", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "th3idx", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_h3indexset_th3index", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_h3_comp" + }, + { + "name": "th3index_are_neighbor_cells", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "origin", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dest", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_are_neighbor_cells", + "sqlfn": "h3_are_neighbor_cells", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_edges" + }, + { + "name": "th3index_cells_to_directed_edge", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "origin", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dest", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cells_to_directed_edge", + "sqlfn": "h3_cells_to_directed_edge", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_edges" + }, + { + "name": "th3index_is_valid_directed_edge", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "edge", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_is_valid_directed_edge", + "sqlfn": "h3_is_valid_directed_edge", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_edges" + }, + { + "name": "th3index_get_directed_edge_origin", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "edge", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_get_directed_edge_origin", + "sqlfn": "h3_get_directed_edge_origin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_edges" + }, + { + "name": "th3index_get_directed_edge_destination", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "edge", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_get_directed_edge_destination", + "sqlfn": "h3_get_directed_edge_destination", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_edges" + }, + { + "name": "th3index_directed_edge_to_boundary", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "edge", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_directed_edge_to_boundary", + "sqlfn": "h3_directed_edge_to_boundary", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_edges" + }, + { + "name": "th3index_cell_to_vertex", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vertex_num", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Th3index_cell_to_vertex", + "sqlfn": "h3_cell_to_vertex", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_vertex" + }, + { + "name": "th3index_vertex_to_latlng", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_vertex_to_latlng", + "sqlfn": "h3_vertex_to_latlng", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_vertex" + }, + { + "name": "th3index_is_valid_vertex", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_is_valid_vertex", + "sqlfn": "h3_is_valid_vertex", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_h3_vertex" + }, + { + "name": "th3index_grid_distance", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "origin", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dest", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_grid_distance", + "sqlfn": "h3_grid_distance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\<->", + "group": "meos_h3_traversal" + }, + { + "name": "th3index_cell_to_local_ij", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "origin", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_cell_to_local_ij", + "sqlfn": "h3_cell_to_local_ij", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_traversal" + }, + { + "name": "th3index_local_ij_to_cell", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "origin", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "coord", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Th3index_local_ij_to_cell", + "sqlfn": "h3_local_ij_to_cell", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_h3_traversal" + }, + { + "name": "th3index_cell_area", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unit", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Th3index_cell_area", + "sqlfn": "h3_cell_area", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_h3_metrics" + }, + { + "name": "th3index_edge_length", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unit", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Th3index_edge_length", + "sqlfn": "h3_edge_length", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_h3_metrics" + }, + { + "name": "tgeogpoint_great_circle_distance", + "file": "meos_h3.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "a", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unit", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Tgeogpoint_great_circle_distance", + "sqlfn": "h3_great_circle_distance", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_h3_metrics" + }, + { + "name": "proj_get_context", + "file": "meos_internal_geo.h", + "returnType": { + "c": "PJ_CONTEXT *", + "canonical": "struct pj_ctx *" + }, + "params": [] + }, + { + "name": "geos_get_context", + "file": "meos_internal_geo.h", + "returnType": { + "c": "GEOSContextHandle_t", + "canonical": "struct GEOSContextHandle_HS *" + }, + "params": [] + }, + { + "name": "datum_geo_round", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "point_round", + "file": "meos_internal_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_geo_base_transf" + }, + { + "name": "stbox_set", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "hasx", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int", + "canonical": "int" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "gbox_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box", + "cType": "const GBOX *", + "canonical": "const GBOX *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "geo_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "geoarr_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "spatial_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "spatialset_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "stbox_set_box3d", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "BOX3D *", + "canonical": "BOX3D *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "stbox_set_gbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "GBOX *", + "canonical": "GBOX *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tstzset_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tstzspan_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "tstzspanset_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_conversion" + }, + { + "name": "stbox_expand", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_transf" + }, + { + "name": "inter_stbox_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "box2", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_set" + }, + { + "name": "tgeogpointinst_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeogpointinst_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeogpointseq_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeogpointseq_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeogpointseqset_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeogpointseqset_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointinst_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointinst_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointseq_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointseq_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointseqset_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeompointseqset_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyinst_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyinst_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyseq_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyseq_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyseqset_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeographyseqset_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryinst_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryinst_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryseq_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryseq_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryseqset_from_mfjson", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "mfjson", + "cType": "json_object *", + "canonical": "struct json_object *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_from_mfjson", + "sqlfn": "tintFromMFJSON", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_inout" + }, + { + "name": "tgeometryseqset_in", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_internal_geo_inout" + }, + { + "name": "tspatial_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "result", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_box" + }, + { + "name": "tspatialseq_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tspatialseqset_set_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeo_restrict_elevation", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeo_restrict_geom", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeo_restrict_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoinst_restrict_geom", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoinst_restrict_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoseq_restrict_geom", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoseq_restrict_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoseqset_restrict_geom", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_restrict" + }, + { + "name": "tgeoseqset_restrict_stbox", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tgeo_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_internal_geo_restrict" + }, + { + "name": "spatial_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spatial_set_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ] + }, + { + "name": "tspatialinst_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_geo_srid" + }, + { + "name": "tpointseq_azimuth", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tpoint_azimuth", + "sqlfn": "azimuth", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseq_cumulative_length", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "prevlength", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Tpoint_cumulative_length", + "sqlfn": "cumulativeLength", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseq_is_simple", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tpoint_is_simple", + "sqlfn": "isSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseq_length", + "file": "meos_internal_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tpoint_length", + "sqlfn": "length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseq_linear_trajectory", + "file": "meos_internal_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tpoint_trajectory", + "sqlfn": "trajectory", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tgeoseq_stboxes", + "file": "meos_internal_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeoseq_split_n_stboxes", + "file": "meos_internal_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "max_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tpointseqset_azimuth", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tpoint_azimuth", + "sqlfn": "azimuth", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseqset_cumulative_length", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tpoint_cumulative_length", + "sqlfn": "cumulativeLength", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseqset_is_simple", + "file": "meos_internal_geo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tpoint_is_simple", + "sqlfn": "isSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseqset_length", + "file": "meos_internal_geo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tpoint_length", + "sqlfn": "length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tgeoseqset_stboxes", + "file": "meos_internal_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeoseqset_split_n_stboxes", + "file": "meos_internal_geo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "max_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_internal_geo_bbox" + }, + { + "name": "tgeominst_tgeoginst", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "oper", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_conversion" + }, + { + "name": "tgeomseq_tgeogseq", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "oper", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_conversion" + }, + { + "name": "tgeomseqset_tgeogseqset", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "oper", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_conversion" + }, + { + "name": "tgeom_tgeog", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "oper", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_conversion" + }, + { + "name": "tgeo_tpoint", + "file": "meos_internal_geo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "oper", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_conversion" + }, + { + "name": "tspatialinst_set_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "TInstant *", + "canonical": "struct TInstant *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_internal_geo_srid" + }, + { + "name": "tpointseq_make_simple", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tpoint_make_simple", + "sqlfn": "makeSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_transf" + }, + { + "name": "tspatialseq_set_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_internal_geo_srid" + }, + { + "name": "tpointseqset_make_simple", + "file": "meos_internal_geo.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tpoint_make_simple", + "sqlfn": "makeSimple", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_transf" + }, + { + "name": "tspatialseqset_set_srid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_internal_geo_srid" + }, + { + "name": "tpointseq_twcentroid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "mdbC": "Tpoint_twcentroid", + "sqlfn": "twCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "tpointseqset_twcentroid", + "file": "meos_internal_geo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "mdbC": "Tpoint_twcentroid", + "sqlfn": "twCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_geo_accessor" + }, + { + "name": "npoint_as_ewkt", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Npoint_as_ewkt", + "sqlfn": "asEWKT", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_as_hexwkb", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ], + "mdbC": "Npoint_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_as_text", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Npoint_as_text", + "sqlfn": "asText", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_as_wkb", + "file": "meos_npoint.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ], + "mdbC": "Npoint_recv", + "sqlfn": "npoint_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_from_hexwkb", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Npoint_from_hexwkb", + "sqlfn": "npointFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_from_wkb", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + } + ], + "mdbC": "Npoint_recv", + "sqlfn": "npoint_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_in", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Npoint_in", + "sqlfn": "npoint_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_out", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Npoint_out", + "sqlfn": "npoint_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "nsegment_in", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Nsegment_in", + "sqlfn": "nsegment_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "nsegment_out", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Nsegment_out", + "sqlfn": "nsegment_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_inout" + }, + { + "name": "npoint_make", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "pos", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Npoint_constructor", + "sqlfn": "npoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_constructor" + }, + { + "name": "nsegment_make", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "pos1", + "cType": "double", + "canonical": "double" + }, + { + "name": "pos2", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Nsegment_constructor", + "sqlfn": "nsegment", + "sqlArity": 1, + "sqlArityMax": 3, + "group": "meos_npoint_base_constructor" + }, + { + "name": "geompoint_to_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geompoint_to_npoint", + "sqlfn": "npoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "geom_to_nsegment", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Geom_to_nsegment", + "sqlfn": "nsegment", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "npoint_to_geompoint", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_to_geompoint", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "npoint_to_nsegment", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_to_nsegment", + "sqlfn": "nsegment", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "npoint_to_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "nsegment_to_geom", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_to_geom", + "sqlfn": "geometry", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "nsegment_to_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_base_conversion" + }, + { + "name": "npoint_hash", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "group": "meos_npoint_base_accessor" + }, + { + "name": "npoint_hash_extended", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_npoint_base_accessor" + }, + { + "name": "npoint_position", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_position", + "sqlfn": "position", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_accessor" + }, + { + "name": "npoint_route", + "file": "meos_npoint.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_route", + "sqlfn": "route", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_accessor" + }, + { + "name": "nsegment_end_position", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_end_position", + "sqlfn": "endPosition", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_accessor" + }, + { + "name": "nsegment_route", + "file": "meos_npoint.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_route", + "sqlfn": "route", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_accessor" + }, + { + "name": "nsegment_start_position", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_start_position", + "sqlfn": "startPosition", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_accessor" + }, + { + "name": "route_exists", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_npoint_base_route" + }, + { + "name": "route_geom", + "file": "meos_npoint.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_npoint_base_route" + }, + { + "name": "route_length", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + } + ], + "group": "meos_npoint_base_route" + }, + { + "name": "npoint_round", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Npoint_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_npoint_base_transf" + }, + { + "name": "nsegment_round", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Nsegment_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_npoint_base_transf" + }, + { + "name": "get_srid_ways", + "file": "meos_npoint.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [], + "group": "meos_npoint_base_srid" + }, + { + "name": "npoint_srid", + "file": "meos_npoint.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_srid" + }, + { + "name": "nsegment_srid", + "file": "meos_npoint.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_base_srid" + }, + { + "name": "npoint_timestamptz_to_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Npoint_timestamptz_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_bbox" + }, + { + "name": "npoint_tstzspan_to_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Npoint_tstzspan_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_bbox" + }, + { + "name": "npoint_cmp", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_cmp", + "sqlfn": "npoint_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_eq", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_eq", + "sqlfn": "npoint_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_ge", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_ge", + "sqlfn": "npoint_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_gt", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_gt", + "sqlfn": "npoint_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_le", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_le", + "sqlfn": "npoint_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_lt", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_lt", + "sqlfn": "npoint_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_ne", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_ne", + "sqlfn": "npoint_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_npoint_base_comp" + }, + { + "name": "npoint_same", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Npoint_same", + "sqlfn": "same", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_cmp", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_cmp", + "sqlfn": "nsegment_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_eq", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_eq", + "sqlfn": "nsegment_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_ge", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_ge", + "sqlfn": "nsegment_ge", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">=", + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_gt", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_gt", + "sqlfn": "nsegment_gt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": ">", + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_le", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_le", + "sqlfn": "nsegment_le", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<=", + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_lt", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_lt", + "sqlfn": "nsegment_lt", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<", + "group": "meos_npoint_base_comp" + }, + { + "name": "nsegment_ne", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns1", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "ns2", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + } + ], + "mdbC": "Nsegment_ne", + "sqlfn": "nsegment_ne", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<>", + "group": "meos_npoint_base_comp" + }, + { + "name": "npointset_in", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_inout" + }, + { + "name": "npointset_out", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_inout" + }, + { + "name": "npointset_make", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Npoint **", + "canonical": "struct Npoint **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_constructor" + }, + { + "name": "npoint_to_set", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_conversion" + }, + { + "name": "npointset_end_value", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_accessor" + }, + { + "name": "npointset_routes", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Npointset_routes", + "sqlfn": "routes", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_accessor" + }, + { + "name": "npointset_start_value", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_accessor" + }, + { + "name": "npointset_value_n", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Npoint **", + "canonical": "struct Npoint **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_set_accessor" + }, + { + "name": "npointset_values", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint **", + "canonical": "struct Npoint **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_set_accessor" + }, + { + "name": "contained_npoint_set", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_npoint_set_setops" + }, + { + "name": "contains_set_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_npoint_set_setops" + }, + { + "name": "intersection_npoint_set", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_npoint_set_setops" + }, + { + "name": "intersection_set_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_npoint_set_setops" + }, + { + "name": "minus_npoint_set", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_npoint_set_setops" + }, + { + "name": "minus_set_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_npoint_set_setops" + }, + { + "name": "npoint_union_transfn", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "group": "meos_npoint_set_setops" + }, + { + "name": "union_npoint_set", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_npoint_set_setops" + }, + { + "name": "union_set_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_npoint_set_setops" + }, + { + "name": "tnpoint_in", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Tnpoint_in", + "sqlfn": "tnpoint_in", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_npoint_inout" + }, + { + "name": "tnpoint_from_mfjson", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "mfjson", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_npoint_inout" + }, + { + "name": "tnpoint_out", + "file": "meos_npoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_npoint_inout" + }, + { + "name": "tnpointinst_make", + "file": "meos_npoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_constructor" + }, + { + "name": "tnpoint_from_base_temp", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_npoint_constructor" + }, + { + "name": "tnpointseq_from_base_tstzset", + "file": "meos_npoint.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_npoint_constructor" + }, + { + "name": "tnpointseq_from_base_tstzspan", + "file": "meos_npoint.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_npoint_constructor" + }, + { + "name": "tnpointseqset_from_base_tstzspanset", + "file": "meos_npoint.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_npoint_constructor" + }, + { + "name": "tgeompoint_to_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tgeompoint_to_tnpoint", + "sqlfn": "tnpoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_conversion" + }, + { + "name": "tnpoint_to_tgeompoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_to_tgeompoint", + "sqlfn": "tgeompoint", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_npoint_conversion" + }, + { + "name": "tnpoint_cumulative_length", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_cumulative_length", + "sqlfn": "cumulativeLength", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_end_value", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_length", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_length", + "sqlfn": "length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_positions", + "file": "meos_npoint.h", + "returnType": { + "c": "Nsegment **", + "canonical": "struct Nsegment **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Tnpoint_positions", + "sqlfn": "positions", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_route", + "file": "meos_npoint.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_route", + "sqlfn": "route", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_routes", + "file": "meos_npoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_routes", + "sqlfn": "routes", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_speed", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_speed", + "sqlfn": "speed", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_start_value", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_trajectory", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_trajectory", + "sqlfn": "trajectory", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_value_at_timestamptz", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Npoint **", + "canonical": "struct Npoint **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_value_n", + "file": "meos_npoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Npoint **", + "canonical": "struct Npoint **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_values", + "file": "meos_npoint.h", + "returnType": { + "c": "Npoint **", + "canonical": "struct Npoint **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_twcentroid", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_twcentroid", + "sqlfn": "twCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_npoint_accessor" + }, + { + "name": "tnpoint_at_geom", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tnpoint_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_at_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Tnpoint_at_npoint", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_at_npointset", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tnpoint_at_npointset", + "sqlfn": "atValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_at_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnpoint_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_minus_geom", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tnpoint_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_minus_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Tnpoint_minus_npoint", + "sqlfn": "minusValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_minus_npointset", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Tnpoint_minus_npointset", + "sqlfn": "minusValues", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_restrict" + }, + { + "name": "tnpoint_minus_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tnpoint_minus_stbox", + "sqlfn": "minusStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_npoint_restrict" + }, + { + "name": "tdistance_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Tdistance_tnpoint_npoint", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_npoint_dist" + }, + { + "name": "tdistance_tnpoint_geo", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdistance_tnpoint_geo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_npoint_dist" + }, + { + "name": "tdistance_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdistance_tnpoint_tnpoint", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_npoint_dist" + }, + { + "name": "nad_tnpoint_geo", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAD_tnpoint_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nad_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "NAD_tnpoint_npoint", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nad_tnpoint_stbox", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_tnpoint_stbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nad_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tnpoint_tnpoint", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nai_tnpoint_geo", + "file": "meos_npoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAI_tnpoint_geo", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nai_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "NAI_tnpoint_npoint", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "nai_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAI_tnpoint_tnpoint", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "shortestline_tnpoint_geo", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Shortestline_tnpoint_geo", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "shortestline_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Shortestline_tnpoint_npoint", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "shortestline_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Shortestline_tnpoint_tnpoint", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_dist" + }, + { + "name": "tnpoint_tcentroid_transfn", + "file": "meos_npoint.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tnpoint_tcentroid_transfn", + "sqlfn": "tCentroid", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_npoint_agg" + }, + { + "name": "always_eq_npoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_npoint_tnpoint", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "always_eq_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Always_eq_tnpoint_npoint", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "always_eq_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_tnpoint_tnpoint", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "always_ne_npoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_npoint_tnpoint", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "always_ne_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Always_ne_tnpoint_npoint", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "always_ne_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_tnpoint_tnpoint", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_eq_npoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_npoint_tnpoint", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_eq_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Ever_eq_tnpoint_npoint", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_eq_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_tnpoint_tnpoint", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_ne_npoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_npoint_tnpoint", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_ne_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Ever_ne_tnpoint_npoint", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "ever_ne_tnpoint_tnpoint", + "file": "meos_npoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_tnpoint_tnpoint", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_npoint_comp_ever" + }, + { + "name": "teq_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Teq_tnpoint_npoint", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_npoint_comp_temp" + }, + { + "name": "tne_tnpoint_npoint", + "file": "meos_npoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ], + "mdbC": "Tne_tnpoint_npoint", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_npoint_comp_temp" + }, + { + "name": "pcpoint_hex_in", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpoint_hex_out", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpoint_from_hexwkb", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpoint_as_hexwkb", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpoint_copy", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_get_pcid", + "file": "meos_pointcloud.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "mdbC": "Pcpoint_pcid", + "sqlfn": "pcid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_hash", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_hash_extended", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_get_x", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + { + "name": "out", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Pcpoint_get_x", + "sqlfn": "getX", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_get_y", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + { + "name": "out", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Pcpoint_get_y", + "sqlfn": "getY", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_get_z", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + { + "name": "out", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Pcpoint_get_z", + "sqlfn": "getZ", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_get_dim", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + { + "name": "name", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "out", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Pcpoint_get_dim", + "sqlfn": "getDim", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpoint_to_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + } + ], + "mdbC": "Pcpoint_to_tpcbox", + "sqlfn": "tpcbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_constructor" + }, + { + "name": "meos_pc_schema", + "file": "meos_pointcloud.h", + "returnType": { + "c": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + "params": [ + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "meos_pc_schema_register", + "file": "meos_pointcloud.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + } + ], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "meos_pc_schema_register_xml", + "file": "meos_pointcloud.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "schema", + "cType": "PCSCHEMA *", + "canonical": "struct PCSCHEMA *" + }, + { + "name": "xml_text", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "meos_pc_schema_xml", + "file": "meos_pointcloud.h", + "returnType": { + "c": "const char *", + "canonical": "const char *" + }, + "params": [ + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "meos_pc_schema_clear", + "file": "meos_pointcloud.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "pcpoint_cmp", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "group": "meos_pointcloud_comp" + }, + { + "name": "pcpoint_eq", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_ne", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_lt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_le", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_gt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_ge", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpatch_hex_in", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpatch_hex_out", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpatch_from_hexwkb", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpatch_as_hexwkb", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "group": "meos_pointcloud_inout" + }, + { + "name": "pcpatch_copy", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_get_pcid", + "file": "meos_pointcloud.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_npoints", + "file": "meos_pointcloud.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_hash", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "mdbC": "Pcpatch_pcid", + "sqlfn": "pcid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpatch_hash_extended", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pointcloud_accessor" + }, + { + "name": "pcpatch_cmp", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "group": "meos_pointcloud_comp" + }, + { + "name": "pcpatch_eq", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_ne", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_lt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_le", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_gt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_ge", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpointset_in", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_inout" + }, + { + "name": "pcpointset_out", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_inout" + }, + { + "name": "pcpointset_make", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Pcpoint **", + "canonical": "struct Pcpoint **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_constructor" + }, + { + "name": "pcpoint_to_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_conversion" + }, + { + "name": "pcpointset_start_value", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpointset_end_value", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpointset_value_n", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Pcpoint **", + "canonical": "struct Pcpoint **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpointset_values", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpoint **", + "canonical": "struct Pcpoint **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "contains_set_pcpoint", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pt", + "cType": "Pcpoint *", + "canonical": "struct Pcpoint *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "contained_pcpoint_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "intersection_pcpoint_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "intersection_set_pcpoint", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "minus_pcpoint_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "minus_set_pcpoint", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "union_pcpoint_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "union_set_pcpoint", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "pcpoint_union_transfn", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ], + "group": "meos_pointcloud_set_setops" + }, + { + "name": "pcpatchset_in", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_inout" + }, + { + "name": "pcpatchset_out", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_inout" + }, + { + "name": "pcpatchset_make", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "Pcpatch **", + "canonical": "struct Pcpatch **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_constructor" + }, + { + "name": "pcpatch_to_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_conversion" + }, + { + "name": "pcpatchset_start_value", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpatchset_end_value", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpatchset_value_n", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Pcpatch **", + "canonical": "struct Pcpatch **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "pcpatchset_values", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Pcpatch **", + "canonical": "struct Pcpatch **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_set_accessor" + }, + { + "name": "contains_set_pcpatch", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pa", + "cType": "Pcpatch *", + "canonical": "struct Pcpatch *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "contained_pcpatch_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "intersection_pcpatch_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "intersection_set_pcpatch", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "minus_pcpatch_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "minus_set_pcpatch", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "union_pcpatch_set", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "union_set_pcpatch", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pointcloud_set_setops" + }, + { + "name": "pcpatch_union_transfn", + "file": "meos_pointcloud.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ], + "group": "meos_pointcloud_set_setops" + }, + { + "name": "tpcbox_in", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pointcloud_box_inout" + }, + { + "name": "tpcbox_out", + "file": "meos_pointcloud.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pointcloud_box_inout" + }, + { + "name": "tpcbox_make", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "hasx", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hasz", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "hast", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "geodetic", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "zmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "period", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "group": "meos_pointcloud_box_constructor" + }, + { + "name": "tpcbox_copy", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_constructor" + }, + { + "name": "pcpatch_to_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_pointcloud_box_conversion" + }, + { + "name": "tpcbox_hasx", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_hasz", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_hast", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_geodetic", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_xmin", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_hasx", + "sqlfn": "hasX", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_xmax", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_xmax", + "sqlfn": "xmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_ymin", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_ymin", + "sqlfn": "ymin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_ymax", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_ymax", + "sqlfn": "ymax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_zmin", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_zmin", + "sqlfn": "zmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_zmax", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ], + "mdbC": "Tpcbox_zmax", + "sqlfn": "zmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_tmin", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Tpcbox_tmin", + "sqlfn": "tmin", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_tmax", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ], + "mdbC": "Tpcbox_tmax", + "sqlfn": "tmax", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_srid", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Tpcbox_srid", + "sqlfn": "SRID", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_pcid", + "file": "meos_pointcloud.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Tpcbox_pcid", + "sqlfn": "pcid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_accessor" + }, + { + "name": "tpcbox_to_stbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Tpcbox_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pointcloud_box_conversion" + }, + { + "name": "tpcbox_expand", + "file": "meos_pointcloud.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_transf" + }, + { + "name": "tpcbox_round", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tpcbox_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_pointcloud_box_transf" + }, + { + "name": "tpcbox_set_srid", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "mdbC": "Tpcbox_set_srid", + "sqlfn": "setSRID", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_box_transf" + }, + { + "name": "union_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_pointcloud_box_setops" + }, + { + "name": "inter_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "result", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + } + ], + "group": "meos_internal_pointcloud_box_setops" + }, + { + "name": "intersection_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_setops" + }, + { + "name": "contains_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Contains_tpcbox_tpcbox", + "sqlfn": "tpcbox_contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_pointcloud_box_topo" + }, + { + "name": "contained_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Contained_tpcbox_tpcbox", + "sqlfn": "tpcbox_contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_pointcloud_box_topo" + }, + { + "name": "overlaps_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Overlaps_tpcbox_tpcbox", + "sqlfn": "tpcbox_overlaps", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "group": "meos_pointcloud_box_topo" + }, + { + "name": "same_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Same_tpcbox_tpcbox", + "sqlfn": "tpcbox_same", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "~=", + "group": "meos_pointcloud_box_topo" + }, + { + "name": "adjacent_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Adjacent_tpcbox_tpcbox", + "sqlfn": "tpcbox_adjacent", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-|-", + "group": "meos_pointcloud_box_topo" + }, + { + "name": "tpcbox_cmp", + "file": "meos_pointcloud.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Tpcbox_cmp", + "sqlfn": "tpcbox_cmp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_box_comp" + }, + { + "name": "tpcbox_eq", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_ne", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_lt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_le", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_gt", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_ge", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "left_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "Tpcbox_eq", + "sqlfn": "tpcbox_eq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "=", + "group": "meos_pointcloud_box_comp" + }, + { + "name": "overleft_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "right_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overright_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "below_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overbelow_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "above_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overabove_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "front_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overfront_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "back_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overback_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "before_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overbefore_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "after_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "overafter_tpcbox_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "group": "meos_pointcloud_box_pos" + }, + { + "name": "ensure_same_pcid_tpcbox", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ] + }, + { + "name": "tpointcloudinst_make", + "file": "meos_pointcloud.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_pointcloud_constructor" + }, + { + "name": "eintersects_tpcpoint_geo", + "file": "meos_pointcloud.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_pointcloud_ever" + }, + { + "name": "nad_tpcpoint_geo", + "file": "meos_pointcloud.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_pointcloud_dist" + }, + { + "name": "pose_as_ewkt", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Pose_as_ewkt", + "sqlfn": "asEWKT", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_as_hexwkb", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ], + "mdbC": "Pose_as_hexwkb", + "sqlfn": "asHexWKB", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_as_text", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Pose_as_text", + "sqlfn": "asText", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_as_wkb", + "file": "meos_pose.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ], + "mdbC": "Pose_recv", + "sqlfn": "pose_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_from_wkb", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + } + ], + "mdbC": "Pose_recv", + "sqlfn": "pose_recv", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_from_hexwkb", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Pose_from_hexwkb", + "sqlfn": "poseFromHexWKB", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_in", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Pose_in", + "sqlfn": "pose_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_out", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Pose_out", + "sqlfn": "pose_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_inout" + }, + { + "name": "pose_from_geopose", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "json", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_as_geopose", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "conformance", + "cType": "int", + "canonical": "int" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pose_base_geopose" + }, + { + "name": "tpose_from_geopose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "json", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Tpose_from_geopose", + "sqlfn": "tposeFromGeoPose", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_as_geopose", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "conformance", + "cType": "int", + "canonical": "int" + }, + { + "name": "precision", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Tpose_as_geopose", + "sqlfn": "asGeoPose", + "sqlArity": 1, + "sqlArityMax": 3, + "group": "meos_pose_geopose_accessor" + }, + { + "name": "pose_apply_geo", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "body", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Pose_apply_geo", + "sqlfn": "applyPose", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_base_geopose" + }, + { + "name": "tpose_apply_geo", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "body", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tpose_apply_geo", + "sqlfn": "applyPose", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_geopose_accessor" + }, + { + "name": "pose_copy", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_constructor" + }, + { + "name": "pose_make_2d", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "theta", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_pose_base_constructor" + }, + { + "name": "pose_make_3d", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + }, + { + "name": "W", + "cType": "double", + "canonical": "double" + }, + { + "name": "X", + "cType": "double", + "canonical": "double" + }, + { + "name": "Y", + "cType": "double", + "canonical": "double" + }, + { + "name": "Z", + "cType": "double", + "canonical": "double" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_pose_base_constructor" + }, + { + "name": "pose_make_point2d", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "theta", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_pose_base_constructor" + }, + { + "name": "pose_make_point3d", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "W", + "cType": "double", + "canonical": "double" + }, + { + "name": "X", + "cType": "double", + "canonical": "double" + }, + { + "name": "Y", + "cType": "double", + "canonical": "double" + }, + { + "name": "Z", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_pose_base_constructor" + }, + { + "name": "pose_to_point", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_conversion" + }, + { + "name": "pose_to_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Pose_to_stbox", + "sqlfn": "stbox", + "sqlArity": 1, + "sqlArityMax": 1, + "sqlop": "::", + "group": "meos_pose_base_conversion" + }, + { + "name": "pose_hash", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_accessor" + }, + { + "name": "pose_hash_extended", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "seed", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_pose_base_accessor" + }, + { + "name": "pose_orientation", + "file": "meos_pose.h", + "returnType": { + "c": "double *", + "canonical": "double *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_pose_base_accessor" + }, + { + "name": "pose_rotation", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_accessor" + }, + { + "name": "pose_yaw", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Pose_yaw", + "sqlfn": "yaw", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_pitch", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Pose_pitch", + "sqlfn": "pitch", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_roll", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Pose_roll", + "sqlfn": "roll", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_angular_distance", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_normalise", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Pose_normalise", + "sqlfn": "normalise", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_base_geopose" + }, + { + "name": "pose_round", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Pose_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_pose_base_transf" + }, + { + "name": "posearr_round", + "file": "meos_pose.h", + "returnType": { + "c": "Pose **", + "canonical": "struct Pose **" + }, + "params": [ + { + "name": "posearr", + "cType": "const Pose **", + "canonical": "const struct Pose **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Posearr_round", + "sqlfn": "round", + "group": "meos_pose_base_transf" + }, + { + "name": "pose_set_srid", + "file": "meos_pose.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "pose", + "cType": "Pose *", + "canonical": "struct Pose *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_pose_base_srid" + }, + { + "name": "pose_srid", + "file": "meos_pose.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_srid" + }, + { + "name": "pose_transform", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + } + ], + "group": "meos_pose_base_srid" + }, + { + "name": "pose_transform_pipeline", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pipelinestr", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "srid", + "cType": "int32_t", + "canonical": "int" + }, + { + "name": "is_forward", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_pose_base_srid" + }, + { + "name": "pose_tstzspan_to_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Pose_tstzspan_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_base_bbox" + }, + { + "name": "pose_timestamptz_to_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Pose_timestamptz_to_stbox", + "sqlfn": "stbox", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_base_bbox" + }, + { + "name": "distance_pose_geo", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_pose_base_dist" + }, + { + "name": "distance_pose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_dist" + }, + { + "name": "distance_pose_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "group": "meos_pose_base_dist" + }, + { + "name": "pose_cmp", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_eq", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_ge", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_gt", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_le", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_lt", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_ne", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_nsame", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "pose_same", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_base_comp" + }, + { + "name": "poseset_in", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Set_in", + "sqlfn": "intset_in", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_inout" + }, + { + "name": "poseset_out", + "file": "meos_pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_out", + "sqlfn": "intset_out", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_inout" + }, + { + "name": "poseset_make", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "values", + "cType": "const Pose **", + "canonical": "const struct Pose **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Set_constructor", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_constructor" + }, + { + "name": "pose_to_set", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Value_to_set", + "sqlfn": "set", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_conversion" + }, + { + "name": "poseset_end_value", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_accessor" + }, + { + "name": "poseset_start_value", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_accessor" + }, + { + "name": "poseset_value_n", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Pose **", + "canonical": "struct Pose **" + } + ], + "mdbC": "Set_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_set_accessor" + }, + { + "name": "poseset_values", + "file": "meos_pose.h", + "returnType": { + "c": "Pose **", + "canonical": "struct Pose **" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Set_values", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_set_accessor" + }, + { + "name": "contained_pose_set", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Contained_value_set", + "sqlfn": "contained", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<@", + "group": "meos_pose_set_setops" + }, + { + "name": "contains_set_pose", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pose", + "cType": "Pose *", + "canonical": "struct Pose *" + } + ], + "mdbC": "Contains_set_value", + "sqlfn": "contains", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "\\@>", + "group": "meos_pose_set_setops" + }, + { + "name": "intersection_pose_set", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pose_set_setops" + }, + { + "name": "intersection_set_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Intersection_set_value", + "sqlfn": "setIntersection", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "*", + "group": "meos_pose_set_setops" + }, + { + "name": "minus_pose_set", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Minus_value_set", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pose_set_setops" + }, + { + "name": "minus_set_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Minus_set_value", + "sqlfn": "setMinus", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "-", + "group": "meos_pose_set_setops" + }, + { + "name": "pose_union_transfn", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "state", + "cType": "Set *", + "canonical": "Set *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_pose_set_setops" + }, + { + "name": "union_pose_set", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pose_set_setops" + }, + { + "name": "union_set_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Union_set_value", + "sqlfn": "setUnion", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "+", + "group": "meos_pose_set_setops" + }, + { + "name": "tpose_from_mfjson", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pose_inout" + }, + { + "name": "tpose_in", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_pose_inout" + }, + { + "name": "tposeinst_make", + "file": "meos_pose.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "mdbC": "Tinstant_constructor", + "sqlfn": "tint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_constructor" + }, + { + "name": "tpose_from_base_temp", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_constructor" + }, + { + "name": "tposeseq_from_base_tstzset", + "file": "meos_pose.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "group": "meos_pose_constructor" + }, + { + "name": "tposeseq_from_base_tstzspan", + "file": "meos_pose.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_pose_constructor" + }, + { + "name": "tposeseqset_from_base_tstzspanset", + "file": "meos_pose.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_pose_constructor" + }, + { + "name": "tpose_make", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "tpoint", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "tradius", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpose_make", + "sqlfn": "tpose", + "group": "meos_pose_conversion" + }, + { + "name": "tpose_to_tpoint", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_conversion" + }, + { + "name": "tpose_end_value", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_value", + "sqlfn": "endValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_points", + "file": "meos_pose.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpose_points", + "sqlfn": "points", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_rotation", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_accessor" + }, + { + "name": "tpose_yaw", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_pitch", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_roll", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_speed", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpose_speed", + "sqlfn": "speed", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_angular_speed", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpose_angular_speed", + "sqlfn": "angularSpeed", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_geopose_accessor" + }, + { + "name": "tpose_start_value", + "file": "meos_pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_trajectory", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpose_trajectory", + "sqlfn": "atGeometry", + "group": "meos_pose_accessor" + }, + { + "name": "tpose_value_at_timestamptz", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Pose **", + "canonical": "struct Pose **" + } + ], + "mdbC": "Temporal_value_at_timestamptz", + "sqlfn": "valueAtTimestamp", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_value_n", + "file": "meos_pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Pose **", + "canonical": "struct Pose **" + } + ], + "mdbC": "Temporal_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_values", + "file": "meos_pose.h", + "returnType": { + "c": "Pose **", + "canonical": "struct Pose **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_valueset", + "sqlfn": "getValues", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_pose_accessor" + }, + { + "name": "tpose_at_geom", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tpose_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_restrict" + }, + { + "name": "tpose_at_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tpose_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_pose_restrict" + }, + { + "name": "tpose_at_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Temporal_at_value", + "sqlfn": "atValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_restrict" + }, + { + "name": "tpose_minus_geom", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tpose_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_restrict" + }, + { + "name": "tpose_minus_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Temporal_minus_value", + "sqlfn": "minusValue", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_restrict" + }, + { + "name": "tpose_minus_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Tpose_minus_stbox", + "sqlfn": "minusStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_pose_restrict" + }, + { + "name": "tdistance_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Tdistance_tpose_pose", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_pose_distance" + }, + { + "name": "tdistance_tpose_geo", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tdistance_tpose_geo", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_pose_distance" + }, + { + "name": "tdistance_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tdistance_tpose_tpose", + "sqlfn": "tDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "<->", + "group": "meos_pose_distance" + }, + { + "name": "nad_tpose_geo", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAD_tpose_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "nad_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "NAD_tpose_pose", + "sqlfn": "nearestApproachDistance", + "group": "meos_pose_distance" + }, + { + "name": "nad_tpose_stbox", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "mdbC": "NAD_tpose_geo", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_cbuffer_dist" + }, + { + "name": "nad_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tpose_tpose", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "nai_tpose_geo", + "file": "meos_pose.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "NAI_tpose_geo", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "nai_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "NAI_tpose_pose", + "sqlfn": "nearestApproachInstant", + "group": "meos_pose_distance" + }, + { + "name": "nai_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAI_tpose_tpose", + "sqlfn": "nearestApproachInstant", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "shortestline_tpose_geo", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Shortestline_tpose_geo", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "shortestline_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Shortestline_tpose_pose", + "sqlfn": "shortestLine", + "group": "meos_pose_distance" + }, + { + "name": "shortestline_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Shortestline_tpose_tpose", + "sqlfn": "shortestLine", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pose_distance" + }, + { + "name": "always_eq_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_pose_tpose", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_pose_comp_ever" + }, + { + "name": "always_eq_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Always_eq_tpose_pose", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_pose_comp_ever" + }, + { + "name": "always_eq_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_tpose_tpose", + "sqlfn": "aEq", + "sqlop": "%=", + "group": "meos_pose_comp_ever" + }, + { + "name": "always_ne_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_pose_tpose", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "always_ne_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Always_ne_tpose_pose", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "always_ne_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_tpose_tpose", + "sqlfn": "aNe", + "sqlop": "%<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_eq_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_pose_tpose", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_eq_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Ever_eq_tpose_pose", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_eq_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_tpose_tpose", + "sqlfn": "eEq", + "sqlop": "?=", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_ne_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_pose_tpose", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_ne_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Ever_ne_tpose_pose", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "ever_ne_tpose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_tpose_tpose", + "sqlfn": "eNe", + "sqlop": "?<>", + "group": "meos_pose_comp_ever" + }, + { + "name": "teq_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_pose_tpose", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_pose_comp_temp" + }, + { + "name": "teq_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Teq_tpose_pose", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_pose_comp_temp" + }, + { + "name": "tne_pose_tpose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_pose_tpose", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_pose_comp_temp" + }, + { + "name": "tne_tpose_pose", + "file": "meos_pose.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "mdbC": "Tne_tpose_pose", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_pose_comp_temp" + }, + { + "name": "quadbin_is_valid_index", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "index", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_is_valid_cell", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_tile_to_cell", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "x", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "y", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "z", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_tile", + "file": "meos_quadbin.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "x", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "y", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "z", + "cType": "uint32_t *", + "canonical": "unsigned int *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_get_resolution", + "file": "meos_quadbin.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_parent", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "parent_resolution", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_children", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin *", + "canonical": "unsigned long *" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "children_resolution", + "cType": "uint32_t", + "canonical": "unsigned int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_sibling", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "direction", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_k_ring", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin *", + "canonical": "unsigned long *" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "k", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_point_to_cell", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "longitude", + "cType": "double", + "canonical": "double" + }, + { + "name": "latitude", + "cType": "double", + "canonical": "double" + }, + { + "name": "resolution", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_point", + "file": "meos_quadbin.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "longitude", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "latitude", + "cType": "double *", + "canonical": "double *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_bounding_box", + "file": "meos_quadbin.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "xmin", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "ymin", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "xmax", + "cType": "double *", + "canonical": "double *" + }, + { + "name": "ymax", + "cType": "double *", + "canonical": "double *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_area", + "file": "meos_quadbin.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_index_to_string", + "file": "meos_quadbin.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "index", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_string_to_index", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_cell_to_quadkey", + "file": "meos_quadbin.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin" + }, + { + "name": "quadbin_parse", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin_base_inout" + }, + { + "name": "quadbin_eq", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_ne", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_lt", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_le", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_gt", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_ge", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_cmp", + "file": "meos_quadbin.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "b", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_comp" + }, + { + "name": "quadbin_hash", + "file": "meos_quadbin.h", + "returnType": { + "c": "uint32_t", + "canonical": "unsigned int" + }, + "params": [ + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ], + "group": "meos_quadbin_base_accessor" + }, + { + "name": "quadbin_grid_disk", + "file": "meos_quadbin.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "k", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "quadbin_cell_to_children_set", + "file": "meos_quadbin.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "origin", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "children_resolution", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tquadbin_in", + "file": "meos_quadbin.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin_inout" + }, + { + "name": "tquadbininst_in", + "file": "meos_quadbin.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin_inout" + }, + { + "name": "tquadbinseq_in", + "file": "meos_quadbin.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_quadbin_inout" + }, + { + "name": "tquadbinseqset_in", + "file": "meos_quadbin.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "group": "meos_quadbin_inout" + }, + { + "name": "tquadbin_make", + "file": "meos_quadbin.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "value", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_quadbin_constructor" + }, + { + "name": "tquadbininst_make", + "file": "meos_quadbin.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "value", + "cType": "Quadbin", + "canonical": "unsigned long" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_quadbin_constructor" + }, + { + "name": "tquadbinseq_make", + "file": "meos_quadbin.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "values", + "cType": "const Quadbin *", + "canonical": "const unsigned long *" + }, + { + "name": "times", + "cType": "const TimestampTz *", + "canonical": "const TimestampTz *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_quadbin_constructor" + }, + { + "name": "tquadbinseqset_make", + "file": "meos_quadbin.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "const TSequence **", + "canonical": "const struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_quadbin_constructor" + }, + { + "name": "tquadbin_start_value", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_quadbin_accessor" + }, + { + "name": "tquadbin_end_value", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin", + "canonical": "unsigned long" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_quadbin_accessor" + }, + { + "name": "tquadbin_value_n", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "Quadbin *", + "canonical": "unsigned long *" + } + ], + "group": "meos_quadbin_accessor" + }, + { + "name": "tquadbin_values", + "file": "meos_quadbin.h", + "returnType": { + "c": "Quadbin *", + "canonical": "unsigned long *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_quadbin_accessor" + }, + { + "name": "tquadbin_value_at_timestamptz", + "file": "meos_quadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Quadbin *", + "canonical": "unsigned long *" + } + ], + "group": "meos_quadbin_accessor" + }, + { + "name": "tbigint_to_tquadbin", + "file": "meos_quadbin.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_quadbin_conversion" + }, + { + "name": "tquadbin_to_tbigint", + "file": "meos_quadbin.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_quadbin_conversion" + }, + { + "name": "tquadbin_cell_to_quadkey", + "file": "meos_quadbin.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "trgeometry_out", + "file": "meos_rgeo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_inout" + }, + { + "name": "trgeoinst_make", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "geo_tpose_to_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeometry_to_tpose", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_conversion" + }, + { + "name": "trgeometry_to_tpoint", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_conversion" + }, + { + "name": "trgeometry_to_tgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_to_tgeometry", + "sqlfn": "tgeometry", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_conversion" + }, + { + "name": "trgeometry_end_instant", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_instant", + "sqlfn": "endInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_end_sequence", + "file": "meos_rgeo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_end_sequence", + "sqlfn": "endSequence", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_end_value", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_geom", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_conversion" + }, + { + "name": "trgeometry_instant_n", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_instant_n", + "sqlfn": "instantN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_instants", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant **", + "canonical": "struct TInstant **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_instants", + "sqlfn": "instants", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_points", + "file": "meos_rgeo.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_points", + "sqlfn": "points", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_rotation", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_rotation", + "sqlfn": "rotation", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_segments", + "file": "meos_rgeo.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_segments", + "sqlfn": "segments", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_sequence_n", + "file": "meos_rgeo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "i", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_sequence_n", + "sqlfn": "sequenceN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_sequences", + "file": "meos_rgeo.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Temporal_sequences", + "sqlfn": "sequences", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_start_instant", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_instant", + "sqlfn": "startInstant", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_start_sequence", + "file": "meos_rgeo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Temporal_start_sequence", + "sqlfn": "startSequence", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_start_value", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_start_value", + "sqlfn": "startValue", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_value_n", + "file": "meos_rgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "n", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "GSERIALIZED **", + "canonical": "GSERIALIZED **" + } + ], + "mdbC": "Trgeometry_value_n", + "sqlfn": "valueN", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_traversed_area", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "unary_union", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Trgeometry_traversed_area", + "sqlfn": "traversedArea", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_centroid", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_centroid", + "sqlfn": "centroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_convex_hull", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_convex_hull", + "sqlfn": "convexHull", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_body_point_trajectory", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Trgeometry_body_point_trajectory", + "sqlfn": "bodyPointTrajectory", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_spatialfuncs" + }, + { + "name": "trgeometry_space_boxes", + "file": "meos_rgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Trgeometry_space_boxes", + "sqlfn": "spaceBoxes", + "sqlArity": 4, + "sqlArityMax": 7, + "group": "meos_rgeo_tile" + }, + { + "name": "trgeometry_space_time_boxes", + "file": "meos_rgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "xsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "ysize", + "cType": "double", + "canonical": "double" + }, + { + "name": "zsize", + "cType": "double", + "canonical": "double" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "sorigin", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "bitmatrix", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Trgeometry_space_time_boxes", + "sqlfn": "spaceTimeBoxes", + "sqlArity": 5, + "sqlArityMax": 9, + "group": "meos_rgeo_tile" + }, + { + "name": "trgeometry_stboxes", + "file": "meos_rgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_rgeo_bbox_split" + }, + { + "name": "trgeometry_split_n_stboxes", + "file": "meos_rgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_rgeo_bbox_split" + }, + { + "name": "trgeometry_split_each_n_stboxes", + "file": "meos_rgeo.h", + "returnType": { + "c": "STBox *", + "canonical": "struct STBox *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "elem_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "group": "meos_rgeo_bbox_split" + }, + { + "name": "trgeometry_hausdorff_distance", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_hausdorff_distance", + "sqlfn": "hausdorffDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_analytics_similarity" + }, + { + "name": "trgeometry_frechet_distance", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_frechet_distance", + "sqlfn": "frechetDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_analytics_similarity" + }, + { + "name": "trgeometry_dyntimewarp_distance", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_dyntimewarp_distance", + "sqlfn": "dynTimeWarpDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_analytics_similarity" + }, + { + "name": "trgeometry_frechet_path", + "file": "meos_rgeo.h", + "returnType": { + "c": "Match *", + "canonical": "Match *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Trgeometry_frechet_path", + "sqlfn": "frechetDistancePath", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_analytics_similarity" + }, + { + "name": "trgeometry_dyntimewarp_path", + "file": "meos_rgeo.h", + "returnType": { + "c": "Match *", + "canonical": "Match *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ], + "mdbC": "Trgeometry_dyntimewarp_path", + "sqlfn": "dynTimeWarpPath", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_analytics_similarity" + }, + { + "name": "trgeometry_length", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_length", + "sqlfn": "length", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_cumulative_length", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_cumulative_length", + "sqlfn": "cumulativeLength", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_speed", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_speed", + "sqlfn": "speed", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_twcentroid", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_twcentroid", + "sqlfn": "twCentroid", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_accessor" + }, + { + "name": "trgeometry_append_tinstant", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tinstant", + "sqlfn": "appendInstant", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_append_tsequence", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "Temporal *", + "canonical": "Temporal *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "expand", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_append_tsequence", + "sqlfn": "appendSequence", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_delete_timestamptz", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_timestamptz", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_delete_tstzset", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_delete_tstzspan", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspan", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_delete_tstzspanset", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "connect", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_delete_tstzspanset", + "sqlfn": "deleteTime", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_modif" + }, + { + "name": "trgeometry_round", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ], + "mdbC": "Temporal_round", + "sqlfn": "round", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_rgeo_transf" + }, + { + "name": "trgeometry_set_interp", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "mdbC": "Temporal_set_interp", + "sqlfn": "setInterp", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_rgeo_transf" + }, + { + "name": "trgeometry_to_tinstant", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Trgeometry_to_tinstant", + "sqlfn": "trgeometryInst", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_rgeo_transf" + }, + { + "name": "trgeometry_after_timestamptz", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_after_timestamptz", + "sqlfn": "afterTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_restrict" + }, + { + "name": "trgeometry_before_timestamptz", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Temporal_before_timestamptz", + "sqlfn": "beforeTimestamp", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_restrict" + }, + { + "name": "trgeometry_restrict_values", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeometry_restrict_timestamptz", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeometry_restrict_tstzset", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeometry_restrict_tstzspan", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeometry_restrict_tstzspanset", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeometry_at_geom", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Trgeometry_at_geom", + "sqlfn": "atGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_restrict" + }, + { + "name": "trgeometry_minus_geom", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Trgeometry_minus_geom", + "sqlfn": "minusGeometry", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_restrict" + }, + { + "name": "trgeometry_at_stbox", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Trgeometry_at_stbox", + "sqlfn": "atStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_restrict" + }, + { + "name": "trgeometry_minus_stbox", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + } + ], + "mdbC": "Trgeometry_minus_stbox", + "sqlfn": "minusStbox", + "sqlArity": 2, + "sqlArityMax": 3, + "group": "meos_rgeo_restrict" + }, + { + "name": "tdistance_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "tdistance_trgeometry_tpoint", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "tdistance_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nad_stbox_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nad_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nad_trgeometry_stbox", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nad_trgeometry_tpoint", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nad_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nai_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nai_trgeometry_tpoint", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "nai_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "shortestline_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "shortestline_trgeometry_tpoint", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "shortestline_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_rgeo_dist" + }, + { + "name": "always_eq_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_geo_trgeometry", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "always_eq_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Always_eq_trgeometry_geo", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "always_eq_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_eq_trgeometry_trgeometry", + "sqlfn": "aEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "always_ne_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_geo_trgeometry", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "always_ne_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Always_ne_trgeometry_geo", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "always_ne_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Always_ne_trgeometry_trgeometry", + "sqlfn": "aNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "%<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_eq_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_geo_trgeometry", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_eq_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ever_eq_trgeometry_geo", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_eq_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_eq_trgeometry_trgeometry", + "sqlfn": "eEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?=", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_ne_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_geo_trgeometry", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_ne_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ever_ne_trgeometry_geo", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "ever_ne_trgeometry_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ever_ne_trgeometry_trgeometry", + "sqlfn": "eNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "?<>", + "group": "meos_rgeo_comp_ever" + }, + { + "name": "teq_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Teq_geo_trgeometry", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_rgeo_comp_temp" + }, + { + "name": "teq_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Teq_trgeometry_geo", + "sqlfn": "tEq", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#=", + "group": "meos_rgeo_comp_temp" + }, + { + "name": "tne_geo_trgeometry", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tne_geo_trgeometry", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_rgeo_comp_temp" + }, + { + "name": "tne_trgeometry_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Tne_trgeometry_geo", + "sqlfn": "tNe", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "#<>", + "group": "meos_rgeo_comp_temp" + }, + { + "name": "econtains_geo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_geo_trgeometry", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "acontains_geo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acontains_geo_trgeometry", + "sqlfn": "aContains", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "ecovers_geo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Ecovers_geo_trgeometry", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "acovers_geo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Acovers_geo_trgeometry", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "ecovers_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Ecovers_trgeometry_geo", + "sqlfn": "eCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "acovers_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Acovers_trgeometry_geo", + "sqlfn": "aCovers", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "edisjoint_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Edisjoint_trgeometry_geo", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "adisjoint_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Adisjoint_trgeometry_geo", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "eintersects_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Eintersects_trgeometry_geo", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "aintersects_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Aintersects_trgeometry_geo", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "etouches_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Etouches_trgeometry_geo", + "sqlfn": "eTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "atouches_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ], + "mdbC": "Atouches_trgeometry_geo", + "sqlfn": "aTouches", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "edwithin_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_trgeometry_geo", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "adwithin_trgeo_geo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_trgeometry_geo", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "edisjoint_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Edisjoint_trgeometry_trgeometry", + "sqlfn": "eDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "adisjoint_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Adisjoint_trgeometry_trgeometry", + "sqlfn": "aDisjoint", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_internal_rgeo_rel_ever" + }, + { + "name": "eintersects_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Eintersects_trgeometry_trgeometry", + "sqlfn": "eIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "aintersects_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Aintersects_trgeometry_trgeometry", + "sqlfn": "aIntersects", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "edwithin_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Edwithin_trgeometry_trgeometry", + "sqlfn": "eDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "adwithin_trgeo_trgeo", + "file": "meos_rgeo.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + } + ], + "mdbC": "Adwithin_trgeometry_trgeometry", + "sqlfn": "aDwithin", + "sqlArity": 3, + "sqlArityMax": 3, + "group": "meos_rgeo_rel_ever" + }, + { + "name": "ensure_valid_tnpoint_npoint", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ] + }, + { + "name": "ensure_valid_tnpoint_npointset", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "ensure_valid_tnpoint_geo", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tnpoint_stbox", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_tnpoint_tnpoint", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "tnpointsegm_intersection", + "file": "tnpoint.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "common_rid_tnpoint_npoint", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ] + }, + { + "name": "common_rid_tnpoint_npointset", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "common_rid_tnpoint_tnpoint", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "npoint_collinear", + "file": "tnpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np1", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np2", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "np3", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "npointsegm_interpolate", + "file": "tnpoint.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "start", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "end", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "ratio", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "npointsegm_locate", + "file": "tnpoint.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "start", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "end", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "value", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + } + ] + }, + { + "name": "npointarr_geom", + "file": "tnpoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "points", + "cType": "Npoint **", + "canonical": "struct Npoint **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_npoint_conversion" + }, + { + "name": "nsegmentarr_geom", + "file": "tnpoint.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "segments", + "cType": "Nsegment **", + "canonical": "struct Nsegment **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ], + "group": "meos_internal_npoint_conversion" + }, + { + "name": "nsegmentarr_normalize", + "file": "tnpoint.h", + "returnType": { + "c": "Nsegment **", + "canonical": "struct Nsegment **" + }, + "params": [ + { + "name": "segments", + "cType": "Nsegment **", + "canonical": "struct Nsegment **" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "npoint_wkt_out", + "file": "tnpoint.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "npoint_set", + "file": "tnpoint.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "pos", + "cType": "double", + "canonical": "double" + }, + { + "name": "np", + "cType": "Npoint *", + "canonical": "struct Npoint *" + } + ] + }, + { + "name": "nsegment_set", + "file": "tnpoint.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "pos1", + "cType": "double", + "canonical": "double" + }, + { + "name": "pos2", + "cType": "double", + "canonical": "double" + }, + { + "name": "ns", + "cType": "Nsegment *", + "canonical": "struct Nsegment *" + } + ] + }, + { + "name": "datum_npoint_round", + "file": "tnpoint.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "npoint", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "tnpointinst_tgeompointinst", + "file": "tnpoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnpointseq_tgeompointseq_disc", + "file": "tnpoint.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "is", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnpointseq_tgeompointseq_cont", + "file": "tnpoint.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnpointseqset_tgeompointseqset", + "file": "tnpoint.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "tgeompointinst_tnpointinst", + "file": "tnpoint.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tgeompointseq_tnpointseq", + "file": "tnpoint.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tgeompointseqset_tnpointseqset", + "file": "tnpoint.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "tnpointinst_positions", + "file": "tnpoint.h", + "returnType": { + "c": "Nsegment **", + "canonical": "struct Nsegment **" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnpointseq_positions", + "file": "tnpoint.h", + "returnType": { + "c": "Nsegment **", + "canonical": "struct Nsegment **" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tnpointseqset_positions", + "file": "tnpoint.h", + "returnType": { + "c": "Nsegment **", + "canonical": "struct Nsegment **" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tnpointinst_route", + "file": "tnpoint.h", + "returnType": { + "c": "int64_t", + "canonical": "int64_t" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnpointinst_routes", + "file": "tnpoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnpointseq_disc_routes", + "file": "tnpoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "is", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnpointseq_cont_routes", + "file": "tnpoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnpointseqset_routes", + "file": "tnpoint.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "tnpointseq_linear_positions", + "file": "tnpoint.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tnpoint_restrict_stbox", + "file": "tnpoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_npoint_restrict" + }, + { + "name": "tnpoint_restrict_npoint", + "file": "tnpoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_npoint_restrict" + }, + { + "name": "tnpoint_restrict_npointset", + "file": "tnpoint.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_npoint_restrict" + }, + { + "name": "npoint_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "npointarr_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "nsegment_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ns", + "cType": "const Nsegment *", + "canonical": "const struct Nsegment *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_npoint_accessor" + }, + { + "name": "npoint_timestamptz_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "npoint_tstzspan_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tnpointinst_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tnpointinstarr_set_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tnpointseq_expand_stbox", + "file": "tnpoint_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "datum_npoint_distance", + "file": "tnpoint_distance.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "np1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "np2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ], + "group": "meos_internal_npoint_dist" + }, + { + "name": "npoint_parse", + "file": "tnpoint_parser.h", + "returnType": { + "c": "Npoint *", + "canonical": "struct Npoint *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "nsegment_parse", + "file": "tnpoint_parser.h", + "returnType": { + "c": "Nsegment *", + "canonical": "struct Nsegment *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "contains_rid_tnpoint_bigint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "contained_rid_tnpoint_bigint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "same_rid_tnpoint_bigint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "rid", + "cType": "int64_t", + "canonical": "int64_t" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "overlaps_rid_tnpoint_bigintset", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "contains_rid_tnpoint_bigintset", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "contained_rid_tnpoint_bigintset", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "same_rid_tnpoint_bigintset", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "contains_rid_tnpoint_npoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "contained_rid_npoint_tnpoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "same_rid_tnpoint_npoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "np", + "cType": "const Npoint *", + "canonical": "const struct Npoint *" + }, + { + "name": "invert", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "overlaps_rid_tnpoint_tnpoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "contains_rid_tnpoint_tnpoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "contained_rid_tnpoint_tnpoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "same_rid_tnpoint_tnpoint", + "file": "tnpoint_routeops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_same_rid_tnpointinst", + "file": "tnpoint_spatialfuncs.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tnpoint_restrict_geom", + "file": "tnpoint_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_npoint_restrict" + }, + { + "name": "meos_pc_schema_get_srid", + "file": "meos_schema_hook.h", + "returnType": { + "c": "int32_t", + "canonical": "int" + }, + "params": [ + { + "name": "pcid", + "cType": "uint32_t", + "canonical": "unsigned int" + } + ], + "group": "meos_pointcloud_schema_cache" + }, + { + "name": "ensure_same_pcid_pcpatch", + "file": "pcpatch.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa1", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pa2", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "ensure_valid_pcpatchset_pcpatch", + "file": "pcpatch.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + } + ] + }, + { + "name": "pcpatch_parse", + "file": "pcpatch.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "pcpatch_filter_per_point", + "file": "pcpatch_decompose.h", + "returnType": { + "c": "Pcpatch *", + "canonical": "struct Pcpatch *" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pred", + "cType": "int", + "canonical": "int" + }, + { + "name": "extra", + "cType": "void *", + "canonical": "void *" + }, + { + "name": "keep_when_true", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "pcpatch_any_point_matches", + "file": "pcpatch_decompose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pa", + "cType": "const Pcpatch *", + "canonical": "const struct Pcpatch *" + }, + { + "name": "pred", + "cType": "int", + "canonical": "int" + }, + { + "name": "extra", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "pcpoint_in_tpcbox", + "file": "pcpatch_decompose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "extra", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "pcpoint_intersects_geometry", + "file": "pcpatch_decompose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "extra", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "ensure_same_pcid_pcpoint", + "file": "pcpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pt1", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + }, + { + "name": "pt2", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "ensure_valid_pcpointset_pcpoint", + "file": "pcpoint.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pt", + "cType": "const Pcpoint *", + "canonical": "const struct Pcpoint *" + } + ] + }, + { + "name": "pcpoint_parse", + "file": "pcpoint.h", + "returnType": { + "c": "Pcpoint *", + "canonical": "struct Pcpoint *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "meos_pc_point_serialize", + "file": "pgsql_compat.h", + "returnType": { + "c": "SERIALIZED_POINT *", + "canonical": "SERIALIZED_POINT *" + }, + "params": [ + { + "name": "pcpt", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "meos_pc_point_deserialize", + "file": "pgsql_compat.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "serpt", + "cType": "const SERIALIZED_POINT *", + "canonical": "const SERIALIZED_POINT *" + }, + { + "name": "schema", + "cType": "const PCSCHEMA *", + "canonical": "const struct PCSCHEMA *" + } + ] + }, + { + "name": "meos_pc_patch_serialized_size", + "file": "pgsql_compat.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "patch", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "meos_pc_patch_serialize", + "file": "pgsql_compat.h", + "returnType": { + "c": "SERIALIZED_PATCH *", + "canonical": "struct SERIALIZED_PATCH *" + }, + "params": [ + { + "name": "patch_in", + "cType": "const int *", + "canonical": "const int *" + }, + { + "name": "userdata", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "meos_pc_patch_serialize_to_uncompressed", + "file": "pgsql_compat.h", + "returnType": { + "c": "SERIALIZED_PATCH *", + "canonical": "struct SERIALIZED_PATCH *" + }, + "params": [ + { + "name": "patch_in", + "cType": "const int *", + "canonical": "const int *" + } + ] + }, + { + "name": "meos_pc_patch_deserialize", + "file": "pgsql_compat.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "serpatch", + "cType": "const SERIALIZED_PATCH *", + "canonical": "const struct SERIALIZED_PATCH *" + }, + { + "name": "schema", + "cType": "const PCSCHEMA *", + "canonical": "const struct PCSCHEMA *" + } + ] + }, + { + "name": "tpointcloudinst_set_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + } + ] + }, + { + "name": "tpointcloudinstarr_set_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "box", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + } + ] + }, + { + "name": "tpointcloudseq_expand_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tpointcloudseqarr_set_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + } + ] + }, + { + "name": "tpcbox_extent_transfn", + "file": "tpc_boxops.h", + "returnType": { + "c": "TPCBox *", + "canonical": "struct TPCBox *" + }, + "params": [ + { + "name": "state", + "cType": "TPCBox *", + "canonical": "struct TPCBox *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "Tpc_extent_transfn", + "sqlfn": "extent", + "sqlArity": 2, + "sqlArityMax": 2, + "group": "meos_pointcloud_box_constructor" + }, + { + "name": "boxop_tpointcloud_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "func", + "cType": "int (*)(const TPCBox *, const TPCBox *)", + "canonical": "int (*)(const struct int ()( TPCBox , TPCBox ) *, const struct int ()( TPCBox , TPCBox ) *)" + }, + { + "name": "inverted", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boxop_tpointcloud_tpointcloud", + "file": "tpc_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(const TPCBox *, const TPCBox *)", + "canonical": "int (*)(const struct int ()( TPCBox , TPCBox ) *, const struct int ()( TPCBox , TPCBox ) *)" + } + ] + }, + { + "name": "tpcbox_set_stbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "src", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "dst", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "nad_tpcbox_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "box1", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "box2", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "NAD_tpcbox_tpcbox", + "sqlfn": "overlaps_bbox", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "&&", + "sqlfnAll": [ + "overlaps_bbox", + "contains_bbox", + "contained_bbox", + "same_bbox", + "adjacent_bbox", + "nearestApproachDistance" + ], + "group": "meos_pointcloud_box_dist" + }, + { + "name": "nad_tpointcloud_tpcbox", + "file": "tpc_boxops.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + } + ], + "mdbC": "NAD_tpointcloud_tpcbox", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_pointcloud_box_dist" + }, + { + "name": "nad_tpointcloud_tpointcloud", + "file": "tpc_boxops.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "mdbC": "NAD_tpointcloud_tpointcloud", + "sqlfn": "nearestApproachDistance", + "sqlArity": 2, + "sqlArityMax": 2, + "sqlop": "|=|", + "group": "meos_pointcloud_box_dist" + }, + { + "name": "tpcbox_index_leaf_consistent", + "file": "tpcbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "query", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tpcbox_gist_inner_consistent", + "file": "tpcbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "query", + "cType": "const TPCBox *", + "canonical": "const struct TPCBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tpcbox_index_recheck", + "file": "tpcbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "ensure_valid_pose_geo", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_pose_stbox", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_pose_pose", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ] + }, + { + "name": "ensure_valid_poseset_pose", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ] + }, + { + "name": "pose_collinear", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose3", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "posesegm_interpolate", + "file": "pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "start", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "end", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "posesegm_locate", + "file": "pose.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "start", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "end", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "value", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ] + }, + { + "name": "pose_wkt_out", + "file": "pose.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "extended", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "pose_parse", + "file": "pose.h", + "returnType": { + "c": "Pose *", + "canonical": "struct Pose *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "datum_pose_point", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_rotation", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_yaw", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_pitch", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_roll", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_apply_geo", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "body", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_pose_round", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "pose_distance", + "file": "pose.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "pose1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "pose2", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "pose_set_stbox", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "posearr_set_stbox", + "file": "pose.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "pose_timestamptz_set_stbox", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "pose_tstzspan_set_stbox", + "file": "pose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "p", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ], + "group": "meos_internal_box_constructor" + }, + { + "name": "ensure_valid_tpose_geo", + "file": "tpose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_tpose_pose", + "file": "tpose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ] + }, + { + "name": "ensure_valid_tpose_stbox", + "file": "tpose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_tpose_tpose", + "file": "tpose.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "tposesegm_intersection_value", + "file": "tpose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tposesegm_intersection", + "file": "tpose.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "TimestampTz" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "TimestampTz *" + } + ] + }, + { + "name": "tposeinst_set_stbox", + "file": "tpose_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tposeinstarr_set_stbox", + "file": "tpose_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tposeseq_expand_stbox", + "file": "tpose_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tpose_restrict_geom", + "file": "tpose_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_pose_restrict" + }, + { + "name": "tpose_restrict_stbox", + "file": "tpose_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_pose_restrict" + }, + { + "name": "tpose_restrict_elevation", + "file": "tpose_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "geo_get_srid", + "file": "postgis_ext_defs.in.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "g", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "cstring_to_text", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "text *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "text_to_cstring", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const struct varlena *" + } + ] + }, + { + "name": "bool_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "bool_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "b", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "float8_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "float8_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "num", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "text_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "text *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "text_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const struct varlena *" + } + ] + }, + { + "name": "text_upper", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "text *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const struct varlena *" + } + ], + "group": "meos_base_text" + }, + { + "name": "text_lower", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "text *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const struct varlena *" + } + ], + "group": "meos_base_text" + }, + { + "name": "text_initcap", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "text *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "txt", + "cType": "const text *", + "canonical": "const struct varlena *" + } + ], + "group": "meos_base_text" + }, + { + "name": "add_date_int", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "DateADT", + "canonical": "int" + }, + "params": [ + { + "name": "date", + "cType": "DateADT", + "canonical": "int" + }, + { + "name": "days", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "add_timestamptz_interval", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Timestamp", + "canonical": "long" + }, + "params": [ + { + "name": "tstz", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "date_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "DateADT", + "canonical": "int" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "date_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "date", + "cType": "DateADT", + "canonical": "int" + } + ] + }, + { + "name": "interval_cmp", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "interv1", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "interv2", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "interval_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "pg_interval_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "interval_make", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "years", + "cType": "int32", + "canonical": "int" + }, + { + "name": "months", + "cType": "int32", + "canonical": "int" + }, + { + "name": "weeks", + "cType": "int32", + "canonical": "int" + }, + { + "name": "days", + "cType": "int32", + "canonical": "int" + }, + { + "name": "hours", + "cType": "int32", + "canonical": "int" + }, + { + "name": "mins", + "cType": "int32", + "canonical": "int" + }, + { + "name": "secs", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "interval_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "pg_interval_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "time_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "TimeADT", + "canonical": "long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "time_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "time", + "cType": "TimeADT", + "canonical": "long" + } + ] + }, + { + "name": "timestamp_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Timestamp", + "canonical": "long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "timestamp_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ts", + "cType": "Timestamp", + "canonical": "long" + } + ] + }, + { + "name": "timestamptz_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "pg_timestamptz_in", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "typmod", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "timestamptz_out", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "tstz", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "int32_cmp", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "l", + "cType": "int32", + "canonical": "int" + }, + { + "name": "r", + "cType": "int32", + "canonical": "int" + } + ], + "group": "meos_base_int" + }, + { + "name": "int64_cmp", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "l", + "cType": "int64", + "canonical": "long" + }, + { + "name": "r", + "cType": "int64", + "canonical": "long" + } + ], + "group": "meos_base_int" + }, + { + "name": "float8_exp", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "num", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "float8_ln", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "num", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "float8_log10", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "num", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "add_interval_interval", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "interv1", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "interv2", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "mul_interval_double", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "factor", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_base_types" + }, + { + "name": "minus_date_date", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "int32", + "canonical": "int" + }, + "params": [ + { + "name": "date1", + "cType": "DateADT", + "canonical": "int" + }, + { + "name": "date2", + "cType": "DateADT", + "canonical": "int" + } + ] + }, + { + "name": "minus_date_int", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "DateADT", + "canonical": "int" + }, + "params": [ + { + "name": "date", + "cType": "DateADT", + "canonical": "int" + }, + { + "name": "days", + "cType": "int32", + "canonical": "int" + } + ] + }, + { + "name": "minus_timestamptz_interval", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "tstz", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "interv", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "minus_timestamptz_timestamptz", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Interval *", + "canonical": "Interval *" + }, + "params": [ + { + "name": "tstz1", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "tstz2", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "date_to_timestamp", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "Timestamp", + "canonical": "long" + }, + "params": [ + { + "name": "date", + "cType": "DateADT", + "canonical": "int" + } + ] + }, + { + "name": "date_to_timestamptz", + "file": "postgres_ext_defs.in.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "date", + "cType": "DateADT", + "canonical": "int" + } + ] + }, + { + "name": "ensure_valid_tquadbin_tquadbin", + "file": "tquadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_tquadbin_quadbin", + "file": "tquadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "cell", + "cType": "Quadbin", + "canonical": "unsigned long" + } + ] + }, + { + "name": "ensure_valid_tquadbin_tgeompoint", + "file": "tquadbin.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "datum2_quadbin_eq", + "file": "tquadbin.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "d2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_quadbin_ne", + "file": "tquadbin.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "d2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tquadbininst_set_stbox", + "file": "tquadbin_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tquadbininstarr_set_stbox", + "file": "tquadbin_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "tquadbinseq_expand_stbox", + "file": "tquadbin_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "ensure_has_geom", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_valid_trgeo_geo", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "ensure_valid_trgeo_stbox", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + } + ] + }, + { + "name": "ensure_valid_trgeo_trgeo", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "ensure_valid_trgeo_tpoint", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ] + }, + { + "name": "trgeo_geom_p", + "file": "trgeo.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_internal_rgeo_conversion" + }, + { + "name": "trgeo_wkt_out", + "file": "trgeo.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "extended", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_inout" + }, + { + "name": "geo_tposeinst_to_trgeo", + "file": "trgeo.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ], + "group": "meos_internal_rgeo_constructor" + }, + { + "name": "geo_tposeseq_to_trgeo", + "file": "trgeo.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_rgeo_constructor" + }, + { + "name": "geo_tposeseqset_to_trgeo", + "file": "trgeo.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_rgeo_constructor" + }, + { + "name": "trgeo_value_at_timestamptz", + "file": "trgeo.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ], + "group": "meos_internal_rgeo_accessor" + }, + { + "name": "trgeometry_restrict_value", + "file": "trgeo.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeoinst_geom_p", + "file": "trgeo_inst.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "trgeoinst_pose_varsize", + "file": "trgeo_inst.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "trgeoinst_set_pose", + "file": "trgeo_inst.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "TInstant *", + "canonical": "struct TInstant *" + } + ] + }, + { + "name": "trgeoinst_tposeinst", + "file": "trgeo_inst.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "trgeoinst_make1", + "file": "trgeo_inst.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "trgeoseq_to_tinstant", + "file": "trgeo_inst.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ], + "group": "meos_internal_rgeo_transf" + }, + { + "name": "trgeoseqset_to_tinstant", + "file": "trgeo_inst.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "ts", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_rgeo_transf" + }, + { + "name": "trgeo_restrict_geom", + "file": "trgeo_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "trgeo_restrict_stbox", + "file": "trgeo_spatialfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const STBox *", + "canonical": "const struct STBox *" + }, + { + "name": "border_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_restrict" + }, + { + "name": "spatialrel_trgeo_trav_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "varfunc", + "canonical": "int (*)(int ((*)(int *))(), ...)" + }, + { + "name": "numparam", + "cType": "int", + "canonical": "int" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_contains_geo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_contains_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_contains_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_geo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_covers_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_disjoint_geo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_disjoint_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_disjoint_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_intersects_geo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_intersects_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_intersects_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_touches_geo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_touches_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_touches_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_dwithin_trgeo_geo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "ea_dwithin_trgeo_trgeo", + "file": "trgeo_spatialrels.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "dist", + "cType": "double", + "canonical": "double" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_geo_spatial_rel_ever" + }, + { + "name": "trgeoseq_geom_p", + "file": "trgeo_seq.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "trgeoseq_pose_varsize", + "file": "trgeo_seq.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "trgeoseq_set_pose", + "file": "trgeo_seq.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + } + ] + }, + { + "name": "trgeoseq_tposeseq", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "trgeoseq_make_valid", + "file": "trgeo_seq.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "linear", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseq_make1_exp", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseq_make1", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseq_make_exp", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseq_make", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeoseq_make_free_exp", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseq_make_free", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeoinst_to_tsequence", + "file": "trgeo_seq.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ], + "group": "meos_internal_rgeo_transf" + }, + { + "name": "trgeoseqset_geom_p", + "file": "trgeo_seqset.h", + "returnType": { + "c": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + "params": [ + { + "name": "ts", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "trgeoseqset_tposeseqset", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ] + }, + { + "name": "trgeoseqset_make1_exp", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "trgeoseqset_make_exp", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_internal_rgeo_constructor" + }, + { + "name": "trgeoseqset_make", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeoseqset_make_free", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeoseqset_make_gaps", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + } + ], + "group": "meos_rgeo_constructor" + }, + { + "name": "trgeoseqset_to_tsequence", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + } + ], + "group": "meos_internal_rgeo_transf" + }, + { + "name": "trgeo_to_tsequence", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp_str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Trgeometry_to_tsequence", + "sqlfn": "trgeometrySeq", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_rgeo_transf" + }, + { + "name": "trgeo_to_tsequenceset", + "file": "trgeo_seqset.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interp_str", + "cType": "const char *", + "canonical": "const char *" + } + ], + "mdbC": "Trgeometry_to_tsequenceset", + "sqlfn": "trgeometrySeqSet", + "sqlArity": 1, + "sqlArityMax": 2, + "group": "meos_rgeo_transf" + }, + { + "name": "trgeoinst_set_stbox", + "file": "trgeo_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "trgeoinstarr_static_stbox", + "file": "trgeo_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "trgeoinstarr_rotating_stbox", + "file": "trgeo_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "box", + "cType": "STBox *", + "canonical": "struct STBox *" + } + ] + }, + { + "name": "trgeoinstarr_compute_bbox", + "file": "trgeo_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "geom", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "box", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "ensure_span_isof_type", + "file": "span.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_span_isof_basetype", + "file": "span.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_same_span_type", + "file": "span.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "ensure_valid_span_span", + "file": "span.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "span_deserialize", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "lower", + "cType": "SpanBound *", + "canonical": "struct SpanBound *" + }, + { + "name": "upper", + "cType": "SpanBound *", + "canonical": "struct SpanBound *" + } + ] + }, + { + "name": "span_bound_cmp", + "file": "span.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "b1", + "cType": "const SpanBound *", + "canonical": "const struct SpanBound *" + }, + { + "name": "b2", + "cType": "const SpanBound *", + "canonical": "const struct SpanBound *" + } + ] + }, + { + "name": "span_bound_qsort_cmp", + "file": "span.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "s2", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "span_lower_cmp", + "file": "span.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "span_upper_cmp", + "file": "span.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s1", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "s2", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "span_decr_bound", + "file": "span.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "upper", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_incr_bound", + "file": "span.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "upper", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spanarr_normalize", + "file": "span.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "spans", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "sort", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "span_bounds_shift_scale_value", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "lower", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "upper", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "span_bounds_shift_scale_time", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "lower", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "upper", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "floatspan_floor_ceil_iter", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "func", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "numspan_delta_scale_iter", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "delta", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasdelta", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "scale", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tstzspan_delta_scale_iter", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "origin", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "delta", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "scale", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "numspan_shift_scale_iter", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "shift", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "width", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasshift", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "haswidth", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "delta", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "scale", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "tstzspan_shift_scale1", + "file": "span.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "s", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "shift", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "delta", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "scale", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "mi_span_value", + "file": "span.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ] + }, + { + "name": "dist_double_value_value", + "file": "span.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "trgeo_geom_clip_polygon", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "a2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "pa", + "cType": "const POINTARRAY *", + "canonical": "const POINTARRAY *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_lwpoly", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "a2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "poly", + "cType": "const LWPOLY *", + "canonical": "const LWPOLY *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_box", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "a2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_polygon_posed", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "p_a_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "p_b_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "pose1", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pa", + "cType": "const POINTARRAY *", + "canonical": "const POINTARRAY *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_lwpoly_posed", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "p_a_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "p_b_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "pose1", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "poly", + "cType": "const LWPOLY *", + "canonical": "const LWPOLY *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_box_posed", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "p_a_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "p_b_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "pose1", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "xmin", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymin", + "cType": "double", + "canonical": "double" + }, + { + "name": "xmax", + "cType": "double", + "canonical": "double" + }, + { + "name": "ymax", + "cType": "double", + "canonical": "double" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_lwgeom", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b1", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "a2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "b2", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "geom", + "cType": "const LWGEOM *", + "canonical": "const LWGEOM *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_geom_clip_lwgeom_posed", + "file": "trgeo_geom_clip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "p_a_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "p_b_local", + "cType": "const POINT2D *", + "canonical": "const POINT2D *" + }, + { + "name": "pose1", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const struct Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "geom", + "cType": "const LWGEOM *", + "canonical": "const LWGEOM *" + }, + { + "name": "intervals_out", + "cType": "Span **", + "canonical": "struct Span **" + } + ] + }, + { + "name": "trgeo_parse", + "file": "trgeo_parser.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_same_geom", + "file": "trgeo_utils.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "gs1", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "gs2", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "lwgeom_apply_pose", + "file": "trgeo_utils.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "geom", + "cType": "LWGEOM *", + "canonical": "LWGEOM *" + } + ] + }, + { + "name": "geom_apply_pose", + "file": "trgeo_utils.h", + "returnType": { + "c": "GSERIALIZED *", + "canonical": "GSERIALIZED *" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ], + "group": "meos_internal_rgeo_transf" + }, + { + "name": "geom_radius", + "file": "trgeo_utils.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "gs", + "cType": "const GSERIALIZED *", + "canonical": "const GSERIALIZED *" + } + ] + }, + { + "name": "v_clip_tpoly_point", + "file": "trgeo_vclip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "poly", + "cType": "const LWPOLY *", + "canonical": "const LWPOLY *" + }, + { + "name": "point", + "cType": "const LWPOINT *", + "canonical": "const LWPOINT *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "poly_feature", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "dist", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "v_clip_tpoly_tpoly", + "file": "trgeo_vclip.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "poly1", + "cType": "const LWPOLY *", + "canonical": "const LWPOLY *" + }, + { + "name": "poly2", + "cType": "const LWPOLY *", + "canonical": "const LWPOLY *" + }, + { + "name": "pose1", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "pose2", + "cType": "const Pose *", + "canonical": "const struct Pose *" + }, + { + "name": "poly1_feature", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "poly2_feature", + "cType": "uint32_t *", + "canonical": "unsigned int *" + }, + { + "name": "dist", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "apply_pose_point4d", + "file": "trgeo_vclip.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "p", + "cType": "POINT4D *", + "canonical": "POINT4D *" + }, + { + "name": "pose", + "cType": "const Pose *", + "canonical": "const struct Pose *" + } + ] + }, + { + "name": "tfunc_tinstant", + "file": "lifting.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tsequence", + "file": "lifting.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tsequenceset", + "file": "lifting.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_temporal", + "file": "lifting.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tinstant_base", + "file": "lifting.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tsequence_base", + "file": "lifting.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tsequenceset_base", + "file": "lifting.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_temporal_base", + "file": "lifting.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tinstant_tinstant", + "file": "lifting.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tdiscseq_tdiscseq", + "file": "lifting.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tcontseq_tcontseq", + "file": "lifting.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_tsequenceset_tsequenceset", + "file": "lifting.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "tfunc_temporal_temporal", + "file": "lifting.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "eafunc_temporal_base", + "file": "lifting.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "eafunc_temporal_temporal", + "file": "lifting.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "lfunc_set", + "file": "lifting.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "lfinfo", + "cType": "LiftedFunctionInfo *", + "canonical": "struct LiftedFunctionInfo *" + } + ] + }, + { + "name": "set_out_fn", + "file": "set.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "value_out", + "cType": "outfunc", + "canonical": "char *(*)(int ((*)(int *))(), MeosType, int)" + } + ] + }, + { + "name": "ensure_set_isof_type", + "file": "set.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "settype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_valid_set_set", + "file": "set.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s1", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "s2", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "set_find_value", + "file": "set.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "arg1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "loc", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "set_unnest_state_make", + "file": "set.h", + "returnType": { + "c": "SetUnnestState *", + "canonical": "struct SetUnnestState *" + }, + "params": [ + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "set_unnest_state_next", + "file": "set.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "state", + "cType": "SetUnnestState *", + "canonical": "struct SetUnnestState *" + } + ] + }, + { + "name": "ensure_same_skiplist_subtype", + "file": "skiplist.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "subtype", + "cType": "uint8", + "canonical": "unsigned char" + } + ] + }, + { + "name": "skiplist_set_extra", + "file": "skiplist.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "data", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + } + ] + }, + { + "name": "skiplist_headval", + "file": "skiplist.h", + "returnType": { + "c": "void *", + "canonical": "void *" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + } + ] + }, + { + "name": "common_entry_cmp", + "file": "span_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "i1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "i2", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "span_index_leaf_consistent", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "span_gist_inner_consistent", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "span_index_recheck", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "span_lower_qsort_cmp", + "file": "span_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "b", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "span_upper_qsort_cmp", + "file": "span_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "b", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "getQuadrant2D", + "file": "span_index.h", + "returnType": { + "c": "uint8", + "canonical": "unsigned char" + }, + "params": [ + { + "name": "centroid", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "overlap2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "contain2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "left2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "overLeft2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "right2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "overRight2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "adjacent2D", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "distance_span_nodespan", + "file": "span_index.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "query", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + } + ] + }, + { + "name": "span_spgist_get_span", + "file": "span_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "Span *", + "canonical": "struct Span *" + } + ] + }, + { + "name": "spannode_init", + "file": "span_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "SpanNode *", + "canonical": "struct SpanNode *" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "spannode_copy", + "file": "span_index.h", + "returnType": { + "c": "SpanNode *", + "canonical": "struct SpanNode *" + }, + "params": [ + { + "name": "orig", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + } + ] + }, + { + "name": "spannode_quadtree_next", + "file": "span_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "centroid", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "quadrant", + "cType": "uint8", + "canonical": "unsigned char" + }, + { + "name": "next_nodespan", + "cType": "SpanNode *", + "canonical": "struct SpanNode *" + } + ] + }, + { + "name": "spannode_kdtree_next", + "file": "span_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const SpanNode *", + "canonical": "const struct SpanNode *" + }, + { + "name": "centroid", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "node", + "cType": "uint8", + "canonical": "unsigned char" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "next_nodespan", + "cType": "SpanNode *", + "canonical": "struct SpanNode *" + } + ] + }, + { + "name": "ensure_spanset_isof_type", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "spansettype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_same_spanset_type", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ] + }, + { + "name": "ensure_same_spanset_span_type", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "ensure_valid_spanset_span", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "ensure_valid_spanset_spanset", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "ss2", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ] + }, + { + "name": "spanset_find_value", + "file": "spanset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "v", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "loc", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "datum_and", + "file": "tbool_ops.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_or", + "file": "tbool_ops.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "boolop_tbool_bool", + "file": "tbool_ops.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "b", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boolop_tbool_tbool", + "file": "tbool_ops.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "ensure_same_dimensionality_tbox", + "file": "tbox.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "set_tbox", + "file": "tbox.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ], + "mdbC": "Set_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "span_tbox", + "file": "tbox.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ], + "mdbC": "Span_to_tbox", + "sqlfn": "tbox", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "tbox_tstzspan", + "file": "tbox.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_tstzspan", + "sqlfn": "timeSpan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "tbox_intspan", + "file": "tbox.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_intspan", + "sqlfn": "floatspan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "tbox_floatspan", + "file": "tbox.h", + "returnType": { + "c": "Span *", + "canonical": "struct Span *" + }, + "params": [ + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ], + "mdbC": "Tbox_to_floatspan", + "sqlfn": "floatspan", + "sqlArity": 1, + "sqlArityMax": 1, + "group": "meos_internal_box_conversion" + }, + { + "name": "tbox_index_leaf_consistent", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tbox_gist_inner_consistent", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "key", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tbox_index_recheck", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "strategy", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tboxnode_init", + "file": "tbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "centroid", + "cType": "TBox *", + "canonical": "struct TBox *" + }, + { + "name": "nodebox", + "cType": "TboxNode *", + "canonical": "struct TboxNode *" + } + ] + }, + { + "name": "tboxnode_copy", + "file": "tbox_index.h", + "returnType": { + "c": "TboxNode *", + "canonical": "struct TboxNode *" + }, + "params": [ + { + "name": "box", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + } + ] + }, + { + "name": "getQuadrant4D", + "file": "tbox_index.h", + "returnType": { + "c": "uint8", + "canonical": "unsigned char" + }, + "params": [ + { + "name": "centroid", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "inBox", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "tboxnode_quadtree_next", + "file": "tbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "centroid", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "quadrant", + "cType": "uint8", + "canonical": "unsigned char" + }, + { + "name": "next_nodebox", + "cType": "TboxNode *", + "canonical": "struct TboxNode *" + } + ] + }, + { + "name": "tboxnode_kdtree_next", + "file": "tbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "centroid", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "node", + "cType": "uint8", + "canonical": "unsigned char" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + }, + { + "name": "next_nodebox", + "cType": "TboxNode *", + "canonical": "struct TboxNode *" + } + ] + }, + { + "name": "overlap4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "contain4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "left4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "overLeft4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "right4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "overRight4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "before4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "overBefore4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "after4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "overAfter4D", + "file": "tbox_index.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "distance_tbox_nodebox", + "file": "tbox_index.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "nodebox", + "cType": "const TboxNode *", + "canonical": "const struct TboxNode *" + } + ] + }, + { + "name": "tnumber_spgist_get_tbox", + "file": "tbox_index.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ] + }, + { + "name": "tbox_xmin_cmp", + "file": "tbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "tbox_xmax_cmp", + "file": "tbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "tbox_tmin_cmp", + "file": "tbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "tbox_tmax_cmp", + "file": "tbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "box1", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "box2", + "cType": "const TBox *", + "canonical": "const struct TBox *" + } + ] + }, + { + "name": "tbox_level_cmp", + "file": "tbox_index.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "centroid", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "query", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "level", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tcellindex_type", + "file": "tcellindex.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "dggs_cellops", + "file": "tcellindex.h", + "returnType": { + "c": "const DggsCellOps *", + "canonical": "const struct DggsCellOps *" + }, + "params": [ + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tcellindex_get_resolution", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "tcellindex_is_valid_cell", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "tcellindex_cell_to_parent", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "resolution", + "cType": "int32", + "canonical": "int" + } + ], + "group": "meos_cellindex" + }, + { + "name": "tcellindex_cell_to_point", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "tcellindex_cell_to_boundary", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "tcellindex_cell_area", + "file": "tcellindex.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + } + ], + "group": "meos_cellindex" + }, + { + "name": "datum_min_int32", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_max_int32", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_min_int64", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_max_int64", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_min_float8", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_max_float8", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_int32", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_int64", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_float8", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_min_text", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_max_text", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_double2", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_double3", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_sum_double4", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "temporal_skiplist_common", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "list", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "values", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "upper", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "update", + "cType": "int[32]", + "canonical": "int[32]" + } + ] + }, + { + "name": "temporal_skiplist_merge", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "void **", + "canonical": "void **" + }, + "params": [ + { + "name": "spliced", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "spliced_count", + "cType": "int", + "canonical": "int" + }, + { + "name": "values", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "tofree", + "cType": "void ***", + "canonical": "void ***" + }, + { + "name": "nfree", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tinstant_tagg", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "TInstant **", + "canonical": "struct TInstant **" + }, + "params": [ + { + "name": "instants1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "instants2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "tofree", + "cType": "void ***", + "canonical": "void ***" + }, + { + "name": "nfree", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tsequence_tagg", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "sequences1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count1", + "cType": "int", + "canonical": "int" + }, + { + "name": "sequences2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count2", + "cType": "int", + "canonical": "int" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tcontseq_tagg_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "interpoint", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "temporal_tagg_combinefn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state1", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "state2", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinstant_tagg_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "tinstant_tavg_finalfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tsequence_tavg_finalfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tnumberinst_transform_tavg", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "temporal_transform_tcount", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "temporal_transform_tagg", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "Temporal **", + "canonical": "Temporal **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "func", + "cType": "TInstant *(*)(const TInstant *)", + "canonical": "struct TInstant ()( TInstant ) *(*)(const struct TInstant ()( TInstant ) *)" + } + ] + }, + { + "name": "tsequenceset_tagg_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_tagg_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "temporal_tagg_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "arg2", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "temporal_tagg_transform_transfn", + "file": "temporal_aggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "transform", + "cType": "TInstant *(*)(const TInstant *)", + "canonical": "struct TInstant ()( TInstant ) *(*)(const struct TInstant ()( TInstant ) *)" + } + ] + }, + { + "name": "temporal_similarity", + "file": "temporal_analytics.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "simfunc", + "cType": "SimFunc", + "canonical": "SimFunc" + } + ] + }, + { + "name": "temporal_similarity_path", + "file": "temporal_analytics.h", + "returnType": { + "c": "Match *", + "canonical": "Match *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "simfunc", + "cType": "SimFunc", + "canonical": "SimFunc" + } + ] + }, + { + "name": "temporal_bbox_size", + "file": "temporal_boxops.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "tempype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tinstarr_set_bbox", + "file": "temporal_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "bbox", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "tsequence_compute_bbox", + "file": "temporal_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + } + ] + }, + { + "name": "tseqarr_compute_bbox", + "file": "temporal_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "bbox", + "cType": "void *", + "canonical": "void *" + } + ] + }, + { + "name": "tsequenceset_compute_bbox", + "file": "temporal_boxops.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ss", + "cType": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + } + ] + }, + { + "name": "boxop_temporal_tstzspan", + "file": "temporal_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "func", + "cType": "int (*)(const Span *, const Span *)", + "canonical": "int (*)(const struct int ()( Span , Span ) *, const struct int ()( Span , Span ) *)" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boxop_temporal_temporal", + "file": "temporal_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(const Span *, const Span *)", + "canonical": "int (*)(const struct int ()( Span , Span ) *, const struct int ()( Span , Span ) *)" + } + ] + }, + { + "name": "boxop_tnumber_numspan", + "file": "temporal_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "func", + "cType": "int (*)(const Span *, const Span *)", + "canonical": "int (*)(const struct int ()( Span , Span ) *, const struct int ()( Span , Span ) *)" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boxop_tnumber_tbox", + "file": "temporal_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "func", + "cType": "int (*)(const TBox *, const TBox *)", + "canonical": "int (*)(const struct int ()( TBox , TBox ) *, const struct int ()( TBox , TBox ) *)" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "boxop_tnumber_tnumber", + "file": "temporal_boxops.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(const TBox *, const TBox *)", + "canonical": "int (*)(const struct int ()( TBox , TBox ) *, const struct int ()( TBox , TBox ) *)" + } + ] + }, + { + "name": "eacomp_base_temporal", + "file": "temporal_compops.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "eacomp_temporal_base", + "file": "temporal_compops.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "eacomp_temporal_temporal", + "file": "temporal_compops.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "ever", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tcomp_base_temporal", + "file": "temporal_compops.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + } + ], + "group": "meos_internal_temporal_comp_temp" + }, + { + "name": "tcomp_temporal_base", + "file": "temporal_compops.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + } + ], + "group": "meos_internal_temporal_comp_temp" + }, + { + "name": "tcomp_temporal_temporal", + "file": "temporal_compops.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + } + ], + "group": "meos_internal_temporal_comp_temp" + }, + { + "name": "tdiscseq_at_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tdiscseq_restrict_value", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_restrict_values", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_minus_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tdiscseq_restrict_tstzset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_restrict_tstzspanset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tcontseq_restrict_value_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tcontseq_delete_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tcontseq_delete_tstzset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "tcontseq_delete_tstzspanset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + } + ] + }, + { + "name": "tcontseq_at_tstzset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "tcontseq_minus_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tcontseq_minus_tstzset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + } + ] + }, + { + "name": "tcontseq_minus_tstzspan", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "tcontseq_restrict_value", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tcontseq_restrict_values", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tsequence_at_values_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "set", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tnumberseq_cont_restrict_span_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tnumberseq_cont_restrict_spanset_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tsegment_at_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tcontseq_minus_timestamp_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tcontseq_minus_tstzset_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tcontseq_at_tstzspanset1", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tcontseq_minus_tstzspanset_iter", + "file": "temporal_restrict.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tcontseq_at_tstzspan", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + } + ] + }, + { + "name": "tcontseq_at_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tcontseq_restrict_tstzspanset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_value_at_timestamptz", + "file": "temporal_restrict.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "tnumberseq_disc_restrict_span", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberseq_disc_restrict_spanset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberseq_cont_restrict_span", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "span", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberseq_cont_restrict_spanset", + "file": "temporal_restrict.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberseq_cont_twavg", + "file": "temporal_restrict.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "span_num_bins", + "file": "temporal_tile.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start_bin", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "end_bin", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "temporal_time_bin_init", + "file": "temporal_tile.h", + "returnType": { + "c": "SpanBinState *", + "canonical": "struct SpanBinState *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "nbins", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tbox_tile_state_make", + "file": "temporal_tile.h", + "returnType": { + "c": "TboxGridState *", + "canonical": "struct TboxGridState *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "box", + "cType": "const TBox *", + "canonical": "const struct TBox *" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "xorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tbox_tile_state_next", + "file": "temporal_tile.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "state", + "cType": "TboxGridState *", + "canonical": "struct TboxGridState *" + } + ] + }, + { + "name": "tbox_tile_state_set", + "file": "temporal_tile.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "tunits", + "cType": "int64", + "canonical": "long" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "box", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ] + }, + { + "name": "interval_units", + "file": "temporal_tile.h", + "returnType": { + "c": "int64", + "canonical": "long" + }, + "params": [ + { + "name": "interval", + "cType": "const Interval *", + "canonical": "const Interval *" + } + ] + }, + { + "name": "timestamptz_bin_start", + "file": "temporal_tile.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "timestamp", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "tunits", + "cType": "int64", + "canonical": "long" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "datum_bin", + "file": "temporal_tile.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "size", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "offset", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tnumber_value_time_tile_init", + "file": "temporal_tile.h", + "returnType": { + "c": "TboxGridState *", + "canonical": "struct TboxGridState *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "vsize", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "duration", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "vorigin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "torigin", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "ntiles", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tbox_tile_state_get", + "file": "temporal_tile.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "state", + "cType": "TboxGridState *", + "canonical": "struct TboxGridState *" + }, + { + "name": "box", + "cType": "TBox *", + "canonical": "struct TBox *" + } + ] + }, + { + "name": "temporal_transform_wcount", + "file": "temporal_waggfuncs.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interval", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tnumber_transform_wavg", + "file": "temporal_waggfuncs.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interval", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "count", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "temporal_wagg_transfn", + "file": "temporal_waggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interval", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "min", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "crossings", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "temporal_wagg_transform_transfn", + "file": "temporal_waggfuncs.h", + "returnType": { + "c": "SkipList *", + "canonical": "struct SkipList *" + }, + "params": [ + { + "name": "state", + "cType": "SkipList *", + "canonical": "struct SkipList *" + }, + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "interval", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "transform", + "cType": "TSequence **(*)(const Temporal *, const Interval *, int *)", + "canonical": "struct TSequence ()( Temporal , Interval , int ) **(*)(const Temporal *, const Interval *, int *)" + } + ] + }, + { + "name": "tinstant_set", + "file": "tinstant.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "inst", + "cType": "TInstant *", + "canonical": "struct TInstant *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tnumberinst_double", + "file": "tinstant.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + } + ] + }, + { + "name": "tinstant_to_string", + "file": "tinstant.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "value_out", + "cType": "outfunc", + "canonical": "char *(*)(int ((*)(int *))(), MeosType, int)" + } + ] + }, + { + "name": "tinstant_restrict_values_test", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberinst_restrict_span_test", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "s", + "cType": "const Span *", + "canonical": "const struct Span *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tnumberinst_restrict_spanset_test", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinstant_restrict_tstzset_test", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "s", + "cType": "const Set *", + "canonical": "const Set *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinstant_restrict_tstzspanset_test", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "ss", + "cType": "const SpanSet *", + "canonical": "const struct SpanSet *" + }, + { + "name": "atfunc", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "intersection_tinstant_tinstant", + "file": "tinstant.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inter1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "inter2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + } + ] + }, + { + "name": "_mulmat", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "b", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "c", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "arows", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "acols", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "bcols", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_mulvec", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "x", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "y", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "m", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_transpose", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "at", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "m", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_addmat", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "b", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "c", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "m", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_negate", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "m", + "cType": "const int", + "canonical": "const int" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_addeye", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_choldc1", + "file": "tinyekf_meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "p", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_choldcsl", + "file": "tinyekf_meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "A", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "a", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "p", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_cholsl", + "file": "tinyekf_meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "A", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "a", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "p", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_addvec", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "b", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "c", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "_sub", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "b", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "c", + "cType": "float *", + "canonical": "float *" + }, + { + "name": "n", + "cType": "const int", + "canonical": "const int" + } + ] + }, + { + "name": "invert", + "file": "tinyekf_meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "a", + "cType": "const float *", + "canonical": "const float *" + }, + { + "name": "ainv", + "cType": "float *", + "canonical": "float *" + } + ] + }, + { + "name": "ekf_initialize", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ekf", + "cType": "ekf_t *", + "canonical": "struct ekf_t *" + }, + { + "name": "pdiag", + "cType": "const float", + "canonical": "const float" + } + ] + }, + { + "name": "ekf_predict", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ekf", + "cType": "ekf_t *", + "canonical": "struct ekf_t *" + }, + { + "name": "fx", + "cType": "const float", + "canonical": "const float" + }, + { + "name": "F", + "cType": "const float", + "canonical": "const float" + }, + { + "name": "Q", + "cType": "const float", + "canonical": "const float" + } + ] + }, + { + "name": "ekf_update_step3", + "file": "tinyekf_meos.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "ekf", + "cType": "ekf_t *", + "canonical": "struct ekf_t *" + }, + { + "name": "GH", + "cType": "float", + "canonical": "float" + } + ] + }, + { + "name": "ekf_update", + "file": "tinyekf_meos.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "ekf", + "cType": "ekf_t *", + "canonical": "struct ekf_t *" + }, + { + "name": "z", + "cType": "const float", + "canonical": "const float" + }, + { + "name": "hx", + "cType": "const float", + "canonical": "const float" + }, + { + "name": "H", + "cType": "const float", + "canonical": "const float" + }, + { + "name": "R", + "cType": "const float", + "canonical": "const float" + } + ] + }, + { + "name": "tfloat_arithop_turnpt", + "file": "tnumber_mathfuncs.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "param", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "arithop_tnumber_number", + "file": "tnumber_mathfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "oper", + "cType": "TArithmetic", + "canonical": "TArithmetic" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "arithop_tnumber_tnumber", + "file": "tnumber_mathfuncs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "oper", + "cType": "TArithmetic", + "canonical": "TArithmetic" + }, + { + "name": "func", + "cType": "int (*)(Datum *, Datum *, MeosType)", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), MeosType)" + }, + { + "name": "tpfunc", + "cType": "tpfunc_temp", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int ((*)(int *))(), int, int, int *, int *)" + } + ] + }, + { + "name": "float_collinear", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "x1", + "cType": "double", + "canonical": "double" + }, + { + "name": "x2", + "cType": "double", + "canonical": "double" + }, + { + "name": "x3", + "cType": "double", + "canonical": "double" + }, + { + "name": "ratio", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "floatsegm_interpolate", + "file": "tsequence.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "value1", + "cType": "double", + "canonical": "double" + }, + { + "name": "value2", + "cType": "double", + "canonical": "double" + }, + { + "name": "value", + "cType": "long double", + "canonical": "long double" + } + ] + }, + { + "name": "floatsegm_locate", + "file": "tsequence.h", + "returnType": { + "c": "long double", + "canonical": "long double" + }, + "params": [ + { + "name": "value1", + "cType": "double", + "canonical": "double" + }, + { + "name": "value2", + "cType": "double", + "canonical": "double" + }, + { + "name": "value", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tnumbersegm_intersection", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "tsequence_norm_test", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "value1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value3", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "t1", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t2", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t3", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tsequence_join_test", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "removelast", + "cType": "bool *", + "canonical": "int (*)(int *)" + }, + { + "name": "removefirst", + "cType": "bool *", + "canonical": "int (*)(int *)" + } + ] + }, + { + "name": "tsequence_join", + "file": "tsequence.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "removelast", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "removefirst", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tinstarr_normalize", + "file": "tsequence.h", + "returnType": { + "c": "TInstant **", + "canonical": "struct TInstant **" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tcontseq_find_timestamptz", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tdiscseq_find_timestamptz", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "tseqarr2_to_tseqarr", + "file": "tsequence.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence ***", + "canonical": "struct TSequence ***" + }, + { + "name": "countseqs", + "cType": "int *", + "canonical": "int *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "totalseqs", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "ensure_valid_tinstarr_common", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "tsequence_make_exp1", + "file": "tsequence.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "maxcount", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "normalize", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "bbox", + "cType": "const void *", + "canonical": "const void *" + } + ] + }, + { + "name": "synchronize_tsequence_tsequence", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "sync1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "sync2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "interpoint", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tfloatsegm_intersection_value", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "tsegment_intersection_value", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "tsegment_intersection", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "start1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "start2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t1", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "t2", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "tsegment_value_at_timestamptz", + "file": "tsequence.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "start", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "end", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "lower", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "upper", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + } + ] + }, + { + "name": "intersection_tdiscseq_tdiscseq", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inter1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "inter2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "intersection_tcontseq_tdiscseq", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq1", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inter1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "inter2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "intersection_tdiscseq_tcontseq", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "is", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "seq2", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inter1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "inter2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "intersection_tsequence_tinstant", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inter1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "inter2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + } + ] + }, + { + "name": "intersection_tinstant_tsequence", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inter1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "inter2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + } + ] + }, + { + "name": "tsequence_to_string", + "file": "tsequence.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "component", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "value_out", + "cType": "outfunc", + "canonical": "char *(*)(int ((*)(int *))(), MeosType, int)" + } + ] + }, + { + "name": "ensure_increasing_timestamps", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst1", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inst2", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "strict", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "bbox_expand", + "file": "tsequence.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "box1", + "cType": "const void *", + "canonical": "const void *" + }, + { + "name": "box2", + "cType": "void *", + "canonical": "void *" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_valid_tinstarr", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "merge", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "tsequence_make_valid", + "file": "tsequence.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "lower_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "upper_inc", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "tnumberseq_shift_scale_value_iter", + "file": "tsequence.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "origin", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "delta", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "hasdelta", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "scale", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tsequence_shift_scale_time_iter", + "file": "tsequence.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "seq", + "cType": "TSequence *", + "canonical": "struct TSequence *" + }, + { + "name": "delta", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "scale", + "cType": "double", + "canonical": "double" + } + ] + }, + { + "name": "tstepseq_to_linear_iter", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tstepseq_to_linear", + "file": "tsequence.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + } + ] + }, + { + "name": "tsequence_segments_iter", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "tsequence_timestamps_iter", + "file": "tsequence.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "result", + "cType": "TimestampTz *", + "canonical": "long *" + } + ] + }, + { + "name": "tsequenceset_find_timestamptz", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "t", + "cType": "TimestampTz", + "canonical": "long" + }, + { + "name": "loc", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "tseqarr_normalize", + "file": "tsequenceset.h", + "returnType": { + "c": "TSequence **", + "canonical": "struct TSequence **" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "newcount", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "datum_distance", + "file": "tsequenceset.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "value1", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "value2", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "flags", + "cType": "int16", + "canonical": "short" + } + ] + }, + { + "name": "ensure_valid_tinstarr_gaps", + "file": "tsequenceset.h", + "returnType": { + "c": "int *", + "canonical": "int *" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "merge", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "maxdist", + "cType": "double", + "canonical": "double" + }, + { + "name": "maxt", + "cType": "const Interval *", + "canonical": "const Interval *" + }, + { + "name": "nsplits", + "cType": "int *", + "canonical": "int *" + } + ] + }, + { + "name": "ensure_valid_tseqarr", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "synchronize_tsequenceset_tsequence", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "mode", + "cType": "SyncMode", + "canonical": "SyncMode" + }, + { + "name": "inter1", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + }, + { + "name": "inter2", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + } + ] + }, + { + "name": "synchronize_tsequenceset_tsequenceset", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss1", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "ss2", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "mode", + "cType": "SyncMode", + "canonical": "SyncMode" + }, + { + "name": "inter1", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + }, + { + "name": "inter2", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + } + ] + }, + { + "name": "intersection_tsequenceset_tinstant", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "inter1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "inter2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + } + ] + }, + { + "name": "intersection_tinstant_tsequenceset", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "inst", + "cType": "const TInstant *", + "canonical": "const struct TInstant *" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "inter1", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "inter2", + "cType": "TInstant **", + "canonical": "struct TInstant **" + } + ] + }, + { + "name": "intersection_tsequenceset_tdiscseq", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "is", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "inter1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "inter2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "intersection_tdiscseq_tsequenceset", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "is", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "inter1", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "inter2", + "cType": "TSequence **", + "canonical": "struct TSequence **" + } + ] + }, + { + "name": "intersection_tsequence_tsequenceset", + "file": "tsequenceset.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "seq", + "cType": "const TSequence *", + "canonical": "const struct TSequence *" + }, + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "mode", + "cType": "SyncMode", + "canonical": "SyncMode" + }, + { + "name": "inter1", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + }, + { + "name": "inter2", + "cType": "TSequenceSet **", + "canonical": "struct TSequenceSet **" + } + ] + }, + { + "name": "tsequenceset_to_string", + "file": "tsequenceset.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "ss", + "cType": "const TSequenceSet *", + "canonical": "const struct TSequenceSet *" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + }, + { + "name": "value_out", + "cType": "outfunc", + "canonical": "char *(*)(int ((*)(int *))(), MeosType, int)" + } + ] + }, + { + "name": "datum_textcat", + "file": "ttext_funcs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_lower", + "file": "ttext_funcs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_upper", + "file": "ttext_funcs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "datum_initcap", + "file": "ttext_funcs.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + } + ] + }, + { + "name": "textfunc_ttext", + "file": "ttext_funcs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "textfunc_ttext_text", + "file": "ttext_funcs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + }, + { + "name": "invert", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "textfunc_ttext_ttext", + "file": "ttext_funcs.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "temp1", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "temp2", + "cType": "const Temporal *", + "canonical": "const Temporal *" + }, + { + "name": "func", + "cType": "datum_func2", + "canonical": "int (*)(int ((*)(int *))(), int ((*)(int *))())" + } + ] + }, + { + "name": "datum_as_wkb", + "file": "type_inout.h", + "returnType": { + "c": "uint8_t *", + "canonical": "unsigned char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size_out", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ] + }, + { + "name": "datum_as_hexwkb", + "file": "type_inout.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "variant", + "cType": "uint8_t", + "canonical": "unsigned char" + }, + { + "name": "size", + "cType": "size_t *", + "canonical": "int (*)(int *)" + } + ] + }, + { + "name": "type_from_wkb", + "file": "type_inout.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "type_from_hexwkb", + "file": "type_inout.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "hexwkb", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "ensure_end_input", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "type", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "p_whitespace", + "file": "type_parser.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "p_delimchar", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "delim", + "cType": "char", + "canonical": "char" + } + ] + }, + { + "name": "p_obrace", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "ensure_obrace", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "type", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "p_cbrace", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "ensure_cbrace", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "type", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "p_obracket", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "p_cbracket", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "p_oparen", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "ensure_oparen", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "type", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "p_cparen", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "ensure_cparen", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "type", + "cType": "const char *", + "canonical": "const char *" + } + ] + }, + { + "name": "p_comma", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "basetype_parse", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "basetypid", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "delim", + "cType": "char", + "canonical": "char" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "double_parse", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "result", + "cType": "double *", + "canonical": "double *" + } + ] + }, + { + "name": "elem_parse", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "set_parse", + "file": "type_parser.h", + "returnType": { + "c": "Set *", + "canonical": "Set *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "span_parse", + "file": "type_parser.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "span", + "cType": "Span *", + "canonical": "struct Span *" + } + ] + }, + { + "name": "spanset_parse", + "file": "type_parser.h", + "returnType": { + "c": "SpanSet *", + "canonical": "struct SpanSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "spantype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tbox_parse", + "file": "type_parser.h", + "returnType": { + "c": "TBox *", + "canonical": "struct TBox *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "timestamp_parse", + "file": "type_parser.h", + "returnType": { + "c": "TimestampTz", + "canonical": "long" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + } + ] + }, + { + "name": "tinstant_parse", + "file": "type_parser.h", + "returnType": { + "c": "TInstant *", + "canonical": "struct TInstant *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tdiscseq_parse", + "file": "type_parser.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tcontseq_parse", + "file": "type_parser.h", + "returnType": { + "c": "TSequence *", + "canonical": "struct TSequence *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "tsequenceset_parse", + "file": "type_parser.h", + "returnType": { + "c": "TSequenceSet *", + "canonical": "struct TSequenceSet *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "interp", + "cType": "interpType", + "canonical": "interpType" + } + ] + }, + { + "name": "temporal_parse", + "file": "type_parser.h", + "returnType": { + "c": "Temporal *", + "canonical": "Temporal *" + }, + "params": [ + { + "name": "str", + "cType": "const char **", + "canonical": "const char **" + }, + { + "name": "temptype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_copy", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "typid", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_double", + "file": "type_util.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "d", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "double_datum", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "d", + "cType": "double", + "canonical": "double" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "bstring2bytea", + "file": "type_util.h", + "returnType": { + "c": "bytea *", + "canonical": "struct varlena *" + }, + "params": [ + { + "name": "wkb", + "cType": "const uint8_t *", + "canonical": "const unsigned char *" + }, + { + "name": "size", + "cType": "size_t", + "canonical": "int (int *)" + } + ] + }, + { + "name": "meos_strtod", + "file": "type_util.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "endptr", + "cType": "char **", + "canonical": "char **" + } + ] + }, + { + "name": "meos_strtof", + "file": "type_util.h", + "returnType": { + "c": "float", + "canonical": "float" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "endptr", + "cType": "char **", + "canonical": "char **" + } + ] + }, + { + "name": "basetype_in", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "end", + "cType": "bool", + "canonical": "bool" + }, + { + "name": "result", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + } + ] + }, + { + "name": "basetype_out", + "file": "type_util.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "value", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + }, + { + "name": "maxdd", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "pfree_array", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "array", + "cType": "void **", + "canonical": "void **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "string_escape", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "quotes", + "cType": "int", + "canonical": "int" + }, + { + "name": "result", + "cType": "char **", + "canonical": "char **" + } + ] + }, + { + "name": "string_unescape", + "file": "type_util.h", + "returnType": { + "c": "size_t", + "canonical": "size_t" + }, + "params": [ + { + "name": "str", + "cType": "const char *", + "canonical": "const char *" + }, + { + "name": "result", + "cType": "char **", + "canonical": "char **" + } + ] + }, + { + "name": "stringarr_to_string", + "file": "type_util.h", + "returnType": { + "c": "char *", + "canonical": "char *" + }, + "params": [ + { + "name": "strings", + "cType": "char **", + "canonical": "char **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "prefix", + "cType": "char *", + "canonical": "char *" + }, + { + "name": "open", + "cType": "char", + "canonical": "char" + }, + { + "name": "close", + "cType": "char", + "canonical": "char" + }, + { + "name": "quotes", + "cType": "int", + "canonical": "int" + }, + { + "name": "spaces", + "cType": "bool", + "canonical": "bool" + } + ] + }, + { + "name": "datumarr_sort", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tstzarr_sort", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "times", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "spanarr_sort", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "spans", + "cType": "Span *", + "canonical": "struct Span *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tinstarr_sort", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tseqarr_sort", + "file": "type_util.h", + "returnType": { + "c": "void", + "canonical": "void" + }, + "params": [ + { + "name": "sequences", + "cType": "TSequence **", + "canonical": "struct TSequence **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "datumarr_remove_duplicates", + "file": "type_util.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "values", + "cType": "Datum *", + "canonical": "int ((*)(int *))()" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + }, + { + "name": "basetype", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "tstzarr_remove_duplicates", + "file": "type_util.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "values", + "cType": "TimestampTz *", + "canonical": "long *" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "tinstarr_remove_duplicates", + "file": "type_util.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "instants", + "cType": "TInstant **", + "canonical": "struct TInstant **" + }, + { + "name": "count", + "cType": "int", + "canonical": "int" + } + ] + }, + { + "name": "datum_add", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_sub", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_mul", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_div", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_cmp", + "file": "type_util.h", + "returnType": { + "c": "int", + "canonical": "int" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_eq", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_ne", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_lt", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_le", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_gt", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum_ge", + "file": "type_util.h", + "returnType": { + "c": "bool", + "canonical": "bool" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_eq", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_ne", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_lt", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_le", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_gt", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "datum2_ge", + "file": "type_util.h", + "returnType": { + "c": "Datum", + "canonical": "Datum" + }, + "params": [ + { + "name": "l", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "r", + "cType": "Datum", + "canonical": "int ((int *))()" + }, + { + "name": "type", + "cType": "MeosType", + "canonical": "MeosType" + } + ] + }, + { + "name": "hypot3d", + "file": "type_util.h", + "returnType": { + "c": "double", + "canonical": "double" + }, + "params": [ + { + "name": "x", + "cType": "double", + "canonical": "double" + }, + { + "name": "y", + "cType": "double", + "canonical": "double" + }, + { + "name": "z", + "cType": "double", + "canonical": "double" + } + ] + } + ], + "structs": [ + { + "name": "Set", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": 0 + }, + { + "name": "settype", + "cType": "uint8_t", + "offset_bits": 32 + }, + { + "name": "basetype", + "cType": "uint8_t", + "offset_bits": 40 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": 48 + }, + { + "name": "count", + "cType": "int32_t", + "offset_bits": 64 + }, + { + "name": "maxcount", + "cType": "int32_t", + "offset_bits": 96 + }, + { + "name": "bboxsize", + "cType": "int16_t", + "offset_bits": 128 + } + ] + }, + { + "name": "Span", + "file": "meos.h", + "fields": [ + { + "name": "spantype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "basetype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "lower_inc", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "upper_inc", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "padding", + "cType": "char[4]", + "offset_bits": -1 + }, + { + "name": "lower", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "upper", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "SpanSet", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "spansettype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "spantype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "basetype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "padding", + "cType": "char", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "maxcount", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "span", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "elems", + "cType": "Span[1]", + "offset_bits": -1 + } + ] + }, + { + "name": "TBox", + "file": "meos.h", + "fields": [ + { + "name": "period", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "span", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": -1 + } + ] + }, + { + "name": "STBox", + "file": "meos.h", + "fields": [ + { + "name": "period", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "xmin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "ymin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "zmin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "xmax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "ymax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "zmax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": -1 + } + ] + }, + { + "name": "Temporal", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": 0 + }, + { + "name": "temptype", + "cType": "uint8_t", + "offset_bits": 32 + }, + { + "name": "subtype", + "cType": "uint8_t", + "offset_bits": 40 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": 48 + } + ] + }, + { + "name": "TInstant", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "temptype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "subtype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "t", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "value", + "cType": "int", + "offset_bits": -1 + } + ], + "meosType": "TPointInst" + }, + { + "name": "TSequence", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "temptype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "subtype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "maxcount", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "bboxsize", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "padding", + "cType": "char[6]", + "offset_bits": -1 + }, + { + "name": "period", + "cType": "Span", + "offset_bits": -1 + } + ], + "meosType": "TPointSeq" + }, + { + "name": "TSequenceSet", + "file": "meos.h", + "fields": [ + { + "name": "vl_len_", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "temptype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "subtype", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "totalcount", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "maxcount", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "bboxsize", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "padding", + "cType": "int16_t", + "offset_bits": -1 + }, + { + "name": "period", + "cType": "Span", + "offset_bits": -1 + } + ] + }, + { + "name": "Match", + "file": "meos.h", + "fields": [ + { + "name": "i", + "cType": "int", + "offset_bits": 0 + }, + { + "name": "j", + "cType": "int", + "offset_bits": 32 + } + ] + }, + { + "name": "SkipList", + "file": "meos.h", + "fields": [] + }, + { + "name": "MeosArray", + "file": "meos.h", + "fields": [] + }, + { + "name": "RTree", + "file": "meos.h", + "fields": [] + }, + { + "name": "ArrowSchema", + "file": "meos.h", + "fields": [] + }, + { + "name": "ArrowArray", + "file": "meos.h", + "fields": [] + }, + { + "name": "IntSplit", + "file": "meos.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": 0 + }, + { + "name": "bins", + "cType": "int *", + "offset_bits": 64 + }, + { + "name": "count", + "cType": "int", + "offset_bits": 128 + } + ] + }, + { + "name": "FloatSplit", + "file": "meos.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": 0 + }, + { + "name": "bins", + "cType": "double *", + "offset_bits": 64 + }, + { + "name": "count", + "cType": "int", + "offset_bits": 128 + } + ] + }, + { + "name": "TimeSplit", + "file": "meos.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": -1 + }, + { + "name": "bins", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "IntTimeSplit", + "file": "meos.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": -1 + }, + { + "name": "value_bins", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "time_bins", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "FloatTimeSplit", + "file": "meos.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": -1 + }, + { + "name": "value_bins", + "cType": "double *", + "offset_bits": -1 + }, + { + "name": "time_bins", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "MinBoundingCircle", + "file": "meos_geo.h", + "fields": [ + { + "name": "center", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "radius", + "cType": "double", + "offset_bits": -1 + } + ] + }, + { + "name": "MvtGeom", + "file": "meos_geo.h", + "fields": [ + { + "name": "geom", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "times", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "SpaceSplit", + "file": "meos_geo.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": -1 + }, + { + "name": "bins", + "cType": "int **", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "SpaceTimeSplit", + "file": "meos_geo.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": -1 + }, + { + "name": "space_bins", + "cType": "int **", + "offset_bits": -1 + }, + { + "name": "time_bins", + "cType": "int *", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "Cbuffer", + "file": "meos_cbuffer.h", + "fields": [] + }, + { + "name": "temptype_catalog_struct", + "file": "meos_catalog.h", + "fields": [ + { + "name": "temptype", + "cType": "MeosType", + "offset_bits": 0 + }, + { + "name": "basetype", + "cType": "MeosType", + "offset_bits": 32 + } + ] + }, + { + "name": "settype_catalog_struct", + "file": "meos_catalog.h", + "fields": [ + { + "name": "settype", + "cType": "MeosType", + "offset_bits": 0 + }, + { + "name": "basetype", + "cType": "MeosType", + "offset_bits": 32 + } + ] + }, + { + "name": "spantype_catalog_struct", + "file": "meos_catalog.h", + "fields": [ + { + "name": "spantype", + "cType": "MeosType", + "offset_bits": 0 + }, + { + "name": "basetype", + "cType": "MeosType", + "offset_bits": 32 + } + ] + }, + { + "name": "spansettype_catalog_struct", + "file": "meos_catalog.h", + "fields": [ + { + "name": "spansettype", + "cType": "MeosType", + "offset_bits": 0 + }, + { + "name": "spantype", + "cType": "MeosType", + "offset_bits": 32 + } + ] + }, + { + "name": "SkipListElem", + "file": "meos_internal.h", + "fields": [ + { + "name": "key", + "cType": "void *", + "offset_bits": 0 + }, + { + "name": "value", + "cType": "void *", + "offset_bits": 64 + }, + { + "name": "height", + "cType": "int", + "offset_bits": 128 + }, + { + "name": "next", + "cType": "int[32]", + "offset_bits": 160 + } + ] + }, + { + "name": "DatumSplit", + "file": "meos_internal.h", + "fields": [ + { + "name": "fragments", + "cType": "Temporal **", + "offset_bits": 0 + }, + { + "name": "bins", + "cType": "Datum *", + "offset_bits": 64 + }, + { + "name": "count", + "cType": "int", + "offset_bits": 128 + } + ] + }, + { + "name": "double2", + "file": "doublen.h", + "fields": [ + { + "name": "a", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "b", + "cType": "double", + "offset_bits": 64 + } + ] + }, + { + "name": "double3", + "file": "doublen.h", + "fields": [ + { + "name": "a", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "b", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "c", + "cType": "double", + "offset_bits": 128 + } + ] + }, + { + "name": "double4", + "file": "doublen.h", + "fields": [ + { + "name": "a", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "b", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "c", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "d", + "cType": "double", + "offset_bits": 192 + } + ] + }, + { + "name": "STboxNode", + "file": "stbox_index.h", + "fields": [ + { + "name": "left", + "cType": "STBox", + "offset_bits": -1 + }, + { + "name": "right", + "cType": "STBox", + "offset_bits": -1 + } + ] + }, + { + "name": "SortedSTbox", + "file": "stbox_index.h", + "fields": [ + { + "name": "box", + "cType": "STBox", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "GeoAggregateState", + "file": "tgeo_aggfuncs.h", + "fields": [ + { + "name": "srid", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "hasz", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "BitMatrix", + "file": "tgeo_tile.h", + "fields": [ + { + "name": "ndims", + "cType": "int", + "offset_bits": 0 + }, + { + "name": "count", + "cType": "int[4]", + "offset_bits": 32 + }, + { + "name": "byte", + "cType": "uint8_t[1]", + "offset_bits": 160 + } + ] + }, + { + "name": "STboxGridState", + "file": "tgeo_tile.h", + "fields": [ + { + "name": "done", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "hasx", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "hasz", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "hast", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "xsize", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "ysize", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "zsize", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "tunits", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "box", + "cType": "STBox", + "offset_bits": -1 + }, + { + "name": "temp", + "cType": "const Temporal *", + "offset_bits": -1 + }, + { + "name": "bm", + "cType": "BitMatrix *", + "offset_bits": -1 + }, + { + "name": "x", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "y", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "z", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "t", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "ntiles", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "max_coords", + "cType": "int[4]", + "offset_bits": -1 + }, + { + "name": "coords", + "cType": "int[4]", + "offset_bits": -1 + } + ] + }, + { + "name": "Npoint", + "file": "meos_npoint.h", + "fields": [ + { + "name": "rid", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "pos", + "cType": "double", + "offset_bits": -1 + } + ] + }, + { + "name": "Nsegment", + "file": "meos_npoint.h", + "fields": [ + { + "name": "rid", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "pos1", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "pos2", + "cType": "double", + "offset_bits": -1 + } + ] + }, + { + "name": "Pcpoint", + "file": "meos_pointcloud.h", + "fields": [] + }, + { + "name": "Pcpatch", + "file": "meos_pointcloud.h", + "fields": [] + }, + { + "name": "PCSCHEMA", + "file": "meos_pointcloud.h", + "fields": [] + }, + { + "name": "TPCBox", + "file": "meos_pointcloud.h", + "fields": [ + { + "name": "period", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "xmin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "ymin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "zmin", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "xmax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "ymax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "zmax", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": -1 + }, + { + "name": "pcid", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "flags", + "cType": "int16", + "offset_bits": -1 + }, + { + "name": "padding", + "cType": "char[6]", + "offset_bits": -1 + } + ] + }, + { + "name": "Pose", + "file": "meos_pose.h", + "fields": [] + }, + { + "name": "PcpointInTpcboxArgs", + "file": "pcpatch_decompose.h", + "fields": [ + { + "name": "box", + "cType": "const TPCBox *", + "offset_bits": -1 + }, + { + "name": "border_inc", + "cType": "bool", + "offset_bits": -1 + } + ] + }, + { + "name": "SERIALIZED_POINT", + "file": "pgsql_compat.h", + "fields": [ + { + "name": "size", + "cType": "uint32_t", + "offset_bits": 0 + }, + { + "name": "pcid", + "cType": "uint32_t", + "offset_bits": 32 + }, + { + "name": "data", + "cType": "uint8_t[1]", + "offset_bits": 64 + } + ] + }, + { + "name": "SERIALIZED_PATCH", + "file": "pgsql_compat.h", + "fields": [ + { + "name": "size", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "pcid", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "compression", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "npoints", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "bounds", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "data", + "cType": "uint8_t[1]", + "offset_bits": -1 + } + ] + }, + { + "name": "AFFINE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "afac", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "bfac", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "cfac", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "dfac", + "cType": "double", + "offset_bits": 192 + }, + { + "name": "efac", + "cType": "double", + "offset_bits": 256 + }, + { + "name": "ffac", + "cType": "double", + "offset_bits": 320 + }, + { + "name": "gfac", + "cType": "double", + "offset_bits": 384 + }, + { + "name": "hfac", + "cType": "double", + "offset_bits": 448 + }, + { + "name": "ifac", + "cType": "double", + "offset_bits": 512 + }, + { + "name": "xoff", + "cType": "double", + "offset_bits": 576 + }, + { + "name": "yoff", + "cType": "double", + "offset_bits": 640 + }, + { + "name": "zoff", + "cType": "double", + "offset_bits": 704 + } + ] + }, + { + "name": "BOX3D", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "xmin", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "ymin", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "zmin", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "xmax", + "cType": "double", + "offset_bits": 192 + }, + { + "name": "ymax", + "cType": "double", + "offset_bits": 256 + }, + { + "name": "zmax", + "cType": "double", + "offset_bits": 320 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 384 + } + ] + }, + { + "name": "GBOX", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 0 + }, + { + "name": "xmin", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "xmax", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "ymin", + "cType": "double", + "offset_bits": 192 + }, + { + "name": "ymax", + "cType": "double", + "offset_bits": 256 + }, + { + "name": "zmin", + "cType": "double", + "offset_bits": 320 + }, + { + "name": "zmax", + "cType": "double", + "offset_bits": 384 + }, + { + "name": "mmin", + "cType": "double", + "offset_bits": 448 + }, + { + "name": "mmax", + "cType": "double", + "offset_bits": 512 + } + ] + }, + { + "name": "SPHEROID", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "a", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "b", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "f", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "e", + "cType": "double", + "offset_bits": 192 + }, + { + "name": "e_sq", + "cType": "double", + "offset_bits": 256 + }, + { + "name": "radius", + "cType": "double", + "offset_bits": 320 + }, + { + "name": "name", + "cType": "char[20]", + "offset_bits": 384 + } + ] + }, + { + "name": "POINT2D", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "x", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "y", + "cType": "double", + "offset_bits": 64 + } + ] + }, + { + "name": "POINT3DZ", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "x", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "y", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "z", + "cType": "double", + "offset_bits": 128 + } + ] + }, + { + "name": "POINT3D", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "x", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "y", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "z", + "cType": "double", + "offset_bits": 128 + } + ] + }, + { + "name": "POINT3DM", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "x", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "y", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "m", + "cType": "double", + "offset_bits": 128 + } + ] + }, + { + "name": "POINT4D", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "x", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "y", + "cType": "double", + "offset_bits": 64 + }, + { + "name": "z", + "cType": "double", + "offset_bits": 128 + }, + { + "name": "m", + "cType": "double", + "offset_bits": 192 + } + ] + }, + { + "name": "POINTARRAY", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "npoints", + "cType": "uint32_t", + "offset_bits": 0 + }, + { + "name": "maxpoints", + "cType": "uint32_t", + "offset_bits": 32 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 64 + }, + { + "name": "serialized_pointlist", + "cType": "uint8_t *", + "offset_bits": 128 + } + ] + }, + { + "name": "GSERIALIZED", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "size", + "cType": "uint32_t", + "offset_bits": 0 + }, + { + "name": "srid", + "cType": "uint8_t[3]", + "offset_bits": 32 + }, + { + "name": "gflags", + "cType": "uint8_t", + "offset_bits": 56 + }, + { + "name": "data", + "cType": "uint8_t[1]", + "offset_bits": 64 + } + ] + }, + { + "name": "LWGEOM", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "data", + "cType": "void *", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + } + ] + }, + { + "name": "LWPOINT", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "point", + "cType": "POINTARRAY *", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + } + ] + }, + { + "name": "LWLINE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "points", + "cType": "POINTARRAY *", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + } + ] + }, + { + "name": "LWTRIANGLE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "points", + "cType": "POINTARRAY *", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + } + ] + }, + { + "name": "LWCIRCSTRING", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "points", + "cType": "POINTARRAY *", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + } + ] + }, + { + "name": "LWPOLY", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "rings", + "cType": "POINTARRAY **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "nrings", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxrings", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWMPOINT", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWPOINT **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWMLINE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWLINE **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWMPOLY", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWPOLY **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWCOLLECTION", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWGEOM **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWCOMPOUND", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWGEOM **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWCURVEPOLY", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "rings", + "cType": "LWGEOM **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "nrings", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxrings", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWMCURVE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWGEOM **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWMSURFACE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWGEOM **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWPSURFACE", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWPOLY **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "LWTIN", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "bbox", + "cType": "GBOX *", + "offset_bits": 0 + }, + { + "name": "geoms", + "cType": "LWTRIANGLE **", + "offset_bits": 64 + }, + { + "name": "srid", + "cType": "int32_t", + "offset_bits": 128 + }, + { + "name": "flags", + "cType": "lwflags_t", + "offset_bits": 160 + }, + { + "name": "type", + "cType": "uint8_t", + "offset_bits": 176 + }, + { + "name": "pad", + "cType": "char[1]", + "offset_bits": 184 + }, + { + "name": "ngeoms", + "cType": "uint32_t", + "offset_bits": 192 + }, + { + "name": "maxgeoms", + "cType": "uint32_t", + "offset_bits": 224 + } + ] + }, + { + "name": "PJconsts", + "file": "postgis_ext_defs.in.h", + "fields": [] + }, + { + "name": "LWPROJ", + "file": "postgis_ext_defs.in.h", + "fields": [ + { + "name": "pj", + "cType": "PJ *", + "offset_bits": -1 + }, + { + "name": "pipeline_is_forward", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "source_is_latlong", + "cType": "uint8_t", + "offset_bits": -1 + }, + { + "name": "source_semi_major_metre", + "cType": "double", + "offset_bits": -1 + }, + { + "name": "source_semi_minor_metre", + "cType": "double", + "offset_bits": -1 + } + ] + }, + { + "name": "Interval", + "file": "postgres_ext_defs.in.h", + "fields": [ + { + "name": "time", + "cType": "TimeOffset", + "offset_bits": 0 + }, + { + "name": "day", + "cType": "int32", + "offset_bits": 64 + }, + { + "name": "month", + "cType": "int32", + "offset_bits": 96 + } + ] + }, + { + "name": "varlena", + "file": "postgres_ext_defs.in.h", + "fields": [ + { + "name": "vl_len_", + "cType": "char[4]", + "offset_bits": 0 + }, + { + "name": "vl_dat", + "cType": "char[]", + "offset_bits": 32 + } + ] + }, + { + "name": "cfp_elem", + "file": "trgeo_distance.h", + "fields": [ + { + "name": "geom_1", + "cType": "LWGEOM *", + "offset_bits": -1 + }, + { + "name": "geom_2", + "cType": "LWGEOM *", + "offset_bits": -1 + }, + { + "name": "pose_1", + "cType": "Pose *", + "offset_bits": -1 + }, + { + "name": "pose_2", + "cType": "Pose *", + "offset_bits": -1 + }, + { + "name": "free_pose_1", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "free_pose_2", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "cf_1", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "cf_2", + "cType": "uint32_t", + "offset_bits": -1 + }, + { + "name": "t", + "cType": "TimestampTz", + "offset_bits": -1 + }, + { + "name": "store", + "cType": "bool", + "offset_bits": -1 + } + ] + }, + { + "name": "cfp_array", + "file": "trgeo_distance.h", + "fields": [ + { + "name": "count", + "cType": "size_t", + "offset_bits": -1 + }, + { + "name": "size", + "cType": "size_t", + "offset_bits": -1 + }, + { + "name": "arr", + "cType": "cfp_elem *", + "offset_bits": -1 + } + ] + }, + { + "name": "tdist_elem", + "file": "trgeo_distance.h", + "fields": [ + { + "name": "dist", + "cType": "double", + "offset_bits": 0 + }, + { + "name": "t", + "cType": "TimestampTz", + "offset_bits": 64 + } + ] + }, + { + "name": "tdist_array", + "file": "trgeo_distance.h", + "fields": [ + { + "name": "count", + "cType": "size_t", + "offset_bits": -1 + }, + { + "name": "size", + "cType": "size_t", + "offset_bits": -1 + }, + { + "name": "arr", + "cType": "tdist_elem *", + "offset_bits": -1 + } + ] + }, + { + "name": "SpanBound", + "file": "span.h", + "fields": [ + { + "name": "val", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "inclusive", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "lower", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "spantype", + "cType": "uint8", + "offset_bits": -1 + }, + { + "name": "basetype", + "cType": "uint8", + "offset_bits": -1 + } + ] + }, + { + "name": "LiftedFunctionInfo", + "file": "lifting.h", + "fields": [ + { + "name": "func", + "cType": "varfunc", + "offset_bits": -1 + }, + { + "name": "numparam", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "param", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "argtype", + "cType": "MeosType[2]", + "offset_bits": -1 + }, + { + "name": "restype", + "cType": "MeosType", + "offset_bits": -1 + }, + { + "name": "reserror", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "resnull", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "reslinear", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "invert", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "discont", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "ever", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "tpfn_unary", + "cType": "tpfunc_unary", + "offset_bits": -1 + }, + { + "name": "tpfn_adaptive", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "cross_type", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "tpfn_base", + "cType": "tpfunc_base", + "offset_bits": -1 + }, + { + "name": "tpfn_temp", + "cType": "tpfunc_temp", + "offset_bits": -1 + } + ] + }, + { + "name": "SetUnnestState", + "file": "set.h", + "fields": [ + { + "name": "done", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "set", + "cType": "Set *", + "offset_bits": -1 + }, + { + "name": "values", + "cType": "Datum *", + "offset_bits": -1 + } + ] + }, + { + "name": "SpanNode", + "file": "span_index.h", + "fields": [ + { + "name": "left", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "right", + "cType": "Span", + "offset_bits": -1 + } + ] + }, + { + "name": "SortedSpan", + "file": "span_index.h", + "fields": [ + { + "name": "s", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "TboxNode", + "file": "tbox_index.h", + "fields": [ + { + "name": "left", + "cType": "TBox", + "offset_bits": -1 + }, + { + "name": "right", + "cType": "TBox", + "offset_bits": -1 + } + ] + }, + { + "name": "SortedTbox", + "file": "tbox_index.h", + "fields": [ + { + "name": "box", + "cType": "TBox", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "DggsCellOps", + "file": "tcellindex.h", + "fields": [ + { + "name": "celltype", + "cType": "MeosType", + "offset_bits": -1 + }, + { + "name": "settype", + "cType": "MeosType", + "offset_bits": -1 + }, + { + "name": "temptype", + "cType": "MeosType", + "offset_bits": -1 + }, + { + "name": "min_resolution", + "cType": "int32", + "offset_bits": -1 + }, + { + "name": "max_resolution", + "cType": "int32", + "offset_bits": -1 + }, + { + "name": "point_temptype", + "cType": "MeosType", + "offset_bits": -1 + }, + { + "name": "point_srid", + "cType": "int32", + "offset_bits": -1 + }, + { + "name": "get_resolution", + "cType": "int (*)(Datum *)", + "offset_bits": -1 + }, + { + "name": "is_valid_cell", + "cType": "int (*)(Datum *)", + "offset_bits": -1 + }, + { + "name": "cell_to_parent", + "cType": "int (*)(Datum *, Datum *)", + "offset_bits": -1 + }, + { + "name": "cell_to_point", + "cType": "int (*)(Datum *)", + "offset_bits": -1 + }, + { + "name": "cell_to_boundary", + "cType": "int (*)(Datum *)", + "offset_bits": -1 + }, + { + "name": "cell_area", + "cType": "int (*)(Datum *)", + "offset_bits": -1 + } + ] + }, + { + "name": "SimilarityPathState", + "file": "temporal_analytics.h", + "fields": [ + { + "name": "done", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "size", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "path", + "cType": "Match *", + "offset_bits": -1 + } + ] + }, + { + "name": "RTreeNode", + "file": "temporal_rtree.h", + "fields": [ + { + "name": "bboxsize", + "cType": "size_t", + "offset_bits": -1 + }, + { + "name": "count", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "node_type", + "cType": "RTreeNodeType", + "offset_bits": -1 + }, + { + "name": "boxes", + "cType": "char[]", + "offset_bits": -1 + } + ] + }, + { + "name": "SpanBinState", + "file": "temporal_tile.h", + "fields": [ + { + "name": "done", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "basetype", + "cType": "uint8", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "size", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "origin", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "span", + "cType": "Span", + "offset_bits": -1 + }, + { + "name": "to_split", + "cType": "const void *", + "offset_bits": -1 + }, + { + "name": "value", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "nbins", + "cType": "int", + "offset_bits": -1 + } + ] + }, + { + "name": "TboxGridState", + "file": "temporal_tile.h", + "fields": [ + { + "name": "done", + "cType": "bool", + "offset_bits": -1 + }, + { + "name": "i", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "vsize", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "tunits", + "cType": "int64", + "offset_bits": -1 + }, + { + "name": "box", + "cType": "TBox", + "offset_bits": -1 + }, + { + "name": "temp", + "cType": "const Temporal *", + "offset_bits": -1 + }, + { + "name": "value", + "cType": "Datum", + "offset_bits": -1 + }, + { + "name": "t", + "cType": "TimestampTz", + "offset_bits": -1 + }, + { + "name": "ntiles", + "cType": "int", + "offset_bits": -1 + }, + { + "name": "max_coords", + "cType": "int[2]", + "offset_bits": -1 + }, + { + "name": "coords", + "cType": "int[2]", + "offset_bits": -1 + } + ] + }, + { + "name": "ekf_t", + "file": "tinyekf_meos.h", + "fields": [ + { + "name": "x", + "cType": "float", + "offset_bits": -1 + }, + { + "name": "P", + "cType": "float", + "offset_bits": -1 + } + ] + } + ], + "enums": [ + { + "name": "errorCode", + "file": "meos_error.h", + "values": [ + { + "name": "MEOS_SUCCESS", + "value": 0 + }, + { + "name": "MEOS_ERR_INTERNAL_ERROR", + "value": 1 + }, + { + "name": "MEOS_ERR_INTERNAL_TYPE_ERROR", + "value": 2 + }, + { + "name": "MEOS_ERR_VALUE_OUT_OF_RANGE", + "value": 3 + }, + { + "name": "MEOS_ERR_DIVISION_BY_ZERO", + "value": 4 + }, + { + "name": "MEOS_ERR_MEMORY_ALLOC_ERROR", + "value": 5 + }, + { + "name": "MEOS_ERR_AGGREGATION_ERROR", + "value": 6 + }, + { + "name": "MEOS_ERR_DIRECTORY_ERROR", + "value": 7 + }, + { + "name": "MEOS_ERR_FILE_ERROR", + "value": 8 + }, + { + "name": "MEOS_ERR_OUT_OF_MEMORY", + "value": 9 + }, + { + "name": "MEOS_ERR_INVALID_ARG", + "value": 10 + }, + { + "name": "MEOS_ERR_INVALID_ARG_TYPE", + "value": 11 + }, + { + "name": "MEOS_ERR_INVALID_ARG_VALUE", + "value": 12 + }, + { + "name": "MEOS_ERR_FEATURE_NOT_SUPPORTED", + "value": 13 + }, + { + "name": "MEOS_ERR_INDETERMINATE_COLLATION", + "value": 14 + }, + { + "name": "MEOS_ERR_SYNTAX_ERROR", + "value": 15 + }, + { + "name": "MEOS_ERR_NULL_RESULT", + "value": 16 + }, + { + "name": "MEOS_ERR_MFJSON_INPUT", + "value": 20 + }, + { + "name": "MEOS_ERR_MFJSON_OUTPUT", + "value": 21 + }, + { + "name": "MEOS_ERR_TEXT_INPUT", + "value": 22 + }, + { + "name": "MEOS_ERR_TEXT_OUTPUT", + "value": 23 + }, + { + "name": "MEOS_ERR_WKB_INPUT", + "value": 24 + }, + { + "name": "MEOS_ERR_WKB_OUTPUT", + "value": 25 + }, + { + "name": "MEOS_ERR_GEOJSON_INPUT", + "value": 26 + }, + { + "name": "MEOS_ERR_GEOJSON_OUTPUT", + "value": 27 + }, + { + "name": "MEOS_ERR_SQL_JSON_ERROR", + "value": 28 + }, + { + "name": "MEOS_ERR_INVALID_REGULAR_EXPRESSION", + "value": 29 + } + ] + }, + { + "name": "tempSubtype", + "file": "meos.h", + "values": [ + { + "name": "ANYTEMPSUBTYPE", + "value": 0 + }, + { + "name": "TINSTANT", + "value": 1 + }, + { + "name": "TSEQUENCE", + "value": 2 + }, + { + "name": "TSEQUENCESET", + "value": 3 + } + ] + }, + { + "name": "interpType", + "file": "meos.h", + "values": [ + { + "name": "INTERP_NONE", + "value": 0 + }, + { + "name": "DISCRETE", + "value": 1 + }, + { + "name": "STEP", + "value": 2 + }, + { + "name": "LINEAR", + "value": 3 + } + ] + }, + { + "name": "RTreeSearchOp", + "file": "meos.h", + "values": [ + { + "name": "RTREE_OVERLAPS", + "value": 0 + }, + { + "name": "RTREE_CONTAINS", + "value": 1 + }, + { + "name": "RTREE_CONTAINED_BY", + "value": 2 + } + ] + }, + { + "name": "spatialRel", + "file": "meos_geo.h", + "values": [ + { + "name": "INTERSECTS", + "value": 0 + }, + { + "name": "CONTAINS", + "value": 1 + }, + { + "name": "TOUCHES", + "value": 2 + }, + { + "name": "COVERS", + "value": 3 + } + ] + }, + { + "name": "MeosType", + "file": "meos_catalog.h", + "values": [ + { + "name": "T_UNKNOWN", + "value": 0 + }, + { + "name": "T_BOOL", + "value": 1 + }, + { + "name": "T_DATE", + "value": 2 + }, + { + "name": "T_DATEMULTIRANGE", + "value": 3 + }, + { + "name": "T_DATERANGE", + "value": 4 + }, + { + "name": "T_DATESET", + "value": 5 + }, + { + "name": "T_DATESPAN", + "value": 6 + }, + { + "name": "T_DATESPANSET", + "value": 7 + }, + { + "name": "T_DOUBLE2", + "value": 8 + }, + { + "name": "T_DOUBLE3", + "value": 9 + }, + { + "name": "T_DOUBLE4", + "value": 10 + }, + { + "name": "T_FLOAT8", + "value": 11 + }, + { + "name": "T_FLOATSET", + "value": 12 + }, + { + "name": "T_FLOATSPAN", + "value": 13 + }, + { + "name": "T_FLOATSPANSET", + "value": 14 + }, + { + "name": "T_INT4", + "value": 15 + }, + { + "name": "T_INT4MULTIRANGE", + "value": 16 + }, + { + "name": "T_INT4RANGE", + "value": 17 + }, + { + "name": "T_INTSET", + "value": 18 + }, + { + "name": "T_INTSPAN", + "value": 19 + }, + { + "name": "T_INTSPANSET", + "value": 20 + }, + { + "name": "T_INT8", + "value": 21 + }, + { + "name": "T_INT8MULTIRANGE", + "value": 52 + }, + { + "name": "T_INT8RANGE", + "value": 53 + }, + { + "name": "T_BIGINTSET", + "value": 22 + }, + { + "name": "T_BIGINTSPAN", + "value": 23 + }, + { + "name": "T_BIGINTSPANSET", + "value": 24 + }, + { + "name": "T_STBOX", + "value": 25 + }, + { + "name": "T_TBOOL", + "value": 26 + }, + { + "name": "T_TBOX", + "value": 27 + }, + { + "name": "T_TDOUBLE2", + "value": 28 + }, + { + "name": "T_TDOUBLE3", + "value": 29 + }, + { + "name": "T_TDOUBLE4", + "value": 30 + }, + { + "name": "T_TEXT", + "value": 31 + }, + { + "name": "T_TEXTSET", + "value": 32 + }, + { + "name": "T_TFLOAT", + "value": 33 + }, + { + "name": "T_TIMESTAMPTZ", + "value": 34 + }, + { + "name": "T_TINT", + "value": 35 + }, + { + "name": "T_TSTZMULTIRANGE", + "value": 36 + }, + { + "name": "T_TSTZRANGE", + "value": 37 + }, + { + "name": "T_TSTZSET", + "value": 38 + }, + { + "name": "T_TSTZSPAN", + "value": 39 + }, + { + "name": "T_TSTZSPANSET", + "value": 40 + }, + { + "name": "T_TTEXT", + "value": 41 + }, + { + "name": "T_GEOMETRY", + "value": 42 + }, + { + "name": "T_GEOMSET", + "value": 43 + }, + { + "name": "T_GEOGRAPHY", + "value": 44 + }, + { + "name": "T_GEOGSET", + "value": 45 + }, + { + "name": "T_TGEOMPOINT", + "value": 46 + }, + { + "name": "T_TGEOGPOINT", + "value": 47 + }, + { + "name": "T_NPOINT", + "value": 48 + }, + { + "name": "T_NPOINTSET", + "value": 49 + }, + { + "name": "T_NSEGMENT", + "value": 50 + }, + { + "name": "T_TNPOINT", + "value": 51 + }, + { + "name": "T_POSE", + "value": 54 + }, + { + "name": "T_POSESET", + "value": 55 + }, + { + "name": "T_TPOSE", + "value": 56 + }, + { + "name": "T_CBUFFER", + "value": 57 + }, + { + "name": "T_CBUFFERSET", + "value": 58 + }, + { + "name": "T_TCBUFFER", + "value": 59 + }, + { + "name": "T_TGEOMETRY", + "value": 60 + }, + { + "name": "T_TGEOGRAPHY", + "value": 61 + }, + { + "name": "T_TRGEOMETRY", + "value": 62 + }, + { + "name": "T_TBIGINT", + "value": 63 + }, + { + "name": "T_H3INDEX", + "value": 64 + }, + { + "name": "T_H3INDEXSET", + "value": 65 + }, + { + "name": "T_TH3INDEX", + "value": 66 + }, + { + "name": "T_PCPOINT", + "value": 67 + }, + { + "name": "T_PCPOINTSET", + "value": 68 + }, + { + "name": "T_TPCPOINT", + "value": 69 + }, + { + "name": "T_PCPATCH", + "value": 70 + }, + { + "name": "T_PCPATCHSET", + "value": 71 + }, + { + "name": "T_TPCPATCH", + "value": 72 + }, + { + "name": "T_TPCBOX", + "value": 73 + }, + { + "name": "T_QUADBIN", + "value": 78 + }, + { + "name": "T_QUADBINSET", + "value": 79 + }, + { + "name": "T_TQUADBIN", + "value": 80 + }, + { + "name": "NUM_MEOS_TYPES", + "value": 81 + } + ] + }, + { + "name": "MeosOper", + "file": "meos_catalog.h", + "values": [ + { + "name": "UNKNOWN_OP", + "value": 0 + }, + { + "name": "EQ_OP", + "value": 1 + }, + { + "name": "NE_OP", + "value": 2 + }, + { + "name": "LT_OP", + "value": 3 + }, + { + "name": "LE_OP", + "value": 4 + }, + { + "name": "GT_OP", + "value": 5 + }, + { + "name": "GE_OP", + "value": 6 + }, + { + "name": "ADJACENT_OP", + "value": 7 + }, + { + "name": "UNION_OP", + "value": 8 + }, + { + "name": "MINUS_OP", + "value": 9 + }, + { + "name": "INTERSECT_OP", + "value": 10 + }, + { + "name": "OVERLAPS_OP", + "value": 11 + }, + { + "name": "CONTAINS_OP", + "value": 12 + }, + { + "name": "CONTAINED_OP", + "value": 13 + }, + { + "name": "SAME_OP", + "value": 14 + }, + { + "name": "LEFT_OP", + "value": 15 + }, + { + "name": "OVERLEFT_OP", + "value": 16 + }, + { + "name": "RIGHT_OP", + "value": 17 + }, + { + "name": "OVERRIGHT_OP", + "value": 18 + }, + { + "name": "BELOW_OP", + "value": 19 + }, + { + "name": "OVERBELOW_OP", + "value": 20 + }, + { + "name": "ABOVE_OP", + "value": 21 + }, + { + "name": "OVERABOVE_OP", + "value": 22 + }, + { + "name": "FRONT_OP", + "value": 23 + }, + { + "name": "OVERFRONT_OP", + "value": 24 + }, + { + "name": "BACK_OP", + "value": 25 + }, + { + "name": "OVERBACK_OP", + "value": 26 + }, + { + "name": "BEFORE_OP", + "value": 27 + }, + { + "name": "OVERBEFORE_OP", + "value": 28 + }, + { + "name": "AFTER_OP", + "value": 29 + }, + { + "name": "OVERAFTER_OP", + "value": 30 + }, + { + "name": "EVEREQ_OP", + "value": 31 + }, + { + "name": "EVERNE_OP", + "value": 32 + }, + { + "name": "EVERLT_OP", + "value": 33 + }, + { + "name": "EVERLE_OP", + "value": 34 + }, + { + "name": "EVERGT_OP", + "value": 35 + }, + { + "name": "EVERGE_OP", + "value": 36 + }, + { + "name": "ALWAYSEQ_OP", + "value": 37 + }, + { + "name": "ALWAYSNE_OP", + "value": 38 + }, + { + "name": "ALWAYSLT_OP", + "value": 39 + }, + { + "name": "ALWAYSLE_OP", + "value": 40 + }, + { + "name": "ALWAYSGT_OP", + "value": 41 + }, + { + "name": "ALWAYSGE_OP", + "value": 42 + } + ] + }, + { + "name": "SkipListType", + "file": "meos_internal.h", + "values": [ + { + "name": "SKIPLIST_TEMPORAL", + "value": 0 + }, + { + "name": "SKIPLIST_KEYVALUE", + "value": 1 + } + ] + }, + { + "name": "SyncMode", + "file": "temporal.h", + "values": [ + { + "name": "SYNCHRONIZE_NOCROSS", + "value": 0 + }, + { + "name": "SYNCHRONIZE_CROSS", + "value": 1 + } + ] + }, + { + "name": "TemporalFamily", + "file": "temporal.h", + "values": [ + { + "name": "TEMPORALTYPE", + "value": 0 + }, + { + "name": "TNUMBERTYPE", + "value": 1 + }, + { + "name": "TSPATIALTYPE", + "value": 2 + } + ] + }, + { + "name": "SetOper", + "file": "temporal.h", + "values": [ + { + "name": "UNION", + "value": 0 + }, + { + "name": "INTER", + "value": 1 + }, + { + "name": "MINUS", + "value": 2 + } + ] + }, + { + "name": "CompOper", + "file": "temporal.h", + "values": [ + { + "name": "EQ", + "value": 0 + }, + { + "name": "NE", + "value": 1 + }, + { + "name": "LT", + "value": 2 + }, + { + "name": "LE", + "value": 3 + }, + { + "name": "GT", + "value": 4 + }, + { + "name": "GE", + "value": 5 + } + ] + }, + { + "name": "MEOS_WKB_TSUBTYPE", + "file": "temporal.h", + "values": [ + { + "name": "MEOS_WKB_TINSTANT", + "value": 1 + }, + { + "name": "MEOS_WKB_TSEQUENCE", + "value": 2 + }, + { + "name": "MEOS_WKB_TSEQUENCESET", + "value": 3 + } + ] + }, + { + "name": "ClipOper", + "file": "geo_poly_clip.h", + "values": [ + { + "name": "CL_INTERSECTION", + "value": 0 + }, + { + "name": "CL_UNION", + "value": 1 + }, + { + "name": "CL_DIFFERENCE", + "value": 2 + }, + { + "name": "CL_XOR", + "value": 3 + } + ] + }, + { + "name": "H3Unit", + "file": "th3index_internal.h", + "values": [ + { + "name": "H3_UNIT_KM", + "value": 0 + }, + { + "name": "H3_UNIT_M", + "value": 1 + }, + { + "name": "H3_UNIT_RADS", + "value": 2 + }, + { + "name": "H3_UNIT_KM2", + "value": 3 + }, + { + "name": "H3_UNIT_M2", + "value": 4 + }, + { + "name": "H3_UNIT_RADS2", + "value": 5 + } + ] + }, + { + "name": "nullHandleType", + "file": "meos_json.h", + "values": [ + { + "name": "NULL_INVALID", + "value": 0 + }, + { + "name": "NULL_ERROR", + "value": 1 + }, + { + "name": "NULL_JSON_NULL", + "value": 2 + }, + { + "name": "NULL_DELETE", + "value": 3 + }, + { + "name": "NULL_RETURN", + "value": 4 + } + ] + }, + { + "name": "GeoPoseClass", + "file": "pose_geopose.h", + "values": [ + { + "name": "GEOPOSE_BASIC_QUATERNION", + "value": 0 + }, + { + "name": "GEOPOSE_BASIC_YPR", + "value": 1 + } + ] + }, + { + "name": "SimFunc", + "file": "temporal_analytics.h", + "values": [ + { + "name": "FRECHET", + "value": 0 + }, + { + "name": "DYNTIMEWARP", + "value": 1 + }, + { + "name": "HAUSDORFF", + "value": 2 + }, + { + "name": "LCSS", + "value": 3 + }, + { + "name": "AVERAGEHAUSDORFF", + "value": 4 + } + ] + }, + { + "name": "RTreeNodeType", + "file": "temporal_rtree.h", + "values": [ + { + "name": "RTREE_LEAF", + "value": 0 + }, + { + "name": "RTREE_INNER", + "value": 1 + } + ] + }, + { + "name": "TArithmetic", + "file": "tnumber_mathfuncs.h", + "values": [ + { + "name": "ADD", + "value": 0 + }, + { + "name": "SUB", + "value": 1 + }, + { + "name": "MUL", + "value": 2 + }, + { + "name": "DIV", + "value": 3 + }, + { + "name": "DIST", + "value": 4 + } + ] + } + ], + "portableAliases": { + "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 \u2014 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" + } + ], + "everComparison": [ + { + "operator": "?=", + "bareName": "eEq" + }, + { + "operator": "?<>", + "bareName": "eNe" + }, + { + "operator": "?<", + "bareName": "eLt" + }, + { + "operator": "?<=", + "bareName": "eLe" + }, + { + "operator": "?>", + "bareName": "eGt" + }, + { + "operator": "?>=", + "bareName": "eGe" + } + ], + "alwaysComparison": [ + { + "operator": "%=", + "bareName": "aEq" + }, + { + "operator": "%<>", + "bareName": "aNe" + }, + { + "operator": "%<", + "bareName": "aLt" + }, + { + "operator": "%<=", + "bareName": "aLe" + }, + { + "operator": "%>", + "bareName": "aGt" + }, + { + "operator": "%>=", + "bareName": "aGe" + } + ], + "distance": [ + { + "operator": "<->", + "bareName": "tDistance" + }, + { + "operator": "|=|", + "bareName": "nearestApproachDistance" + } + ], + "same": [ + { + "operator": "~=", + "bareName": "same" + } + ] + }, + "alreadyCanonical": [ + { + "kind": "functions", + "functions": [ + "eIntersects", + "atTime", + "restriction functions", + "spatial-relationship functions" + ] + } + ], + "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 \u2014 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 \u2014 where another engine defers them, that is incomplete work to close (a gap with a plan), never an accepted exclusion.", + "deferralIsError": true + }, + "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 \u2014 do NOT normalize the internal prefix.", + "Goal: 100% parity ecosystem-wide \u2014 every operator has its bare name on every engine, no gaps, no headline exclusions." + ], + "byOperator": { + "&&": "overlaps", + "@>": "contains", + "<@": "contained", + "-|-": "adjacent", + "<<#": "before", + "#>>": "after", + "&<#": "overbefore", + "#&>": "overafter", + "<<": "left", + ">>": "right", + "&<": "overleft", + "&>": "overright", + "<<|": "below", + "|>>": "above", + "&<|": "overbelow", + "|&>": "overabove", + "<>": "back", + "&": "overback", + "#=": "tEq", + "#<>": "tNe", + "#<": "tLt", + "#<=": "tLe", + "#>": "tGt", + "#>=": "tGe", + "?=": "eEq", + "?<>": "eNe", + "?<": "eLt", + "?<=": "eLe", + "?>": "eGt", + "?>=": "eGe", + "%=": "aEq", + "%<>": "aNe", + "%<": "aLt", + "%<=": "aLe", + "%>": "aGt", + "%>=": "aGe", + "<->": "tDistance", + "|=|": "nearestApproachDistance", + "~=": "same" + }, + "byBareName": { + "overlaps": "&&", + "contains": "@>", + "contained": "<@", + "adjacent": "-|-", + "before": "<<#", + "after": "#>>", + "overbefore": "&<#", + "overafter": "#&>", + "left": "<<", + "right": ">>", + "overleft": "&<", + "overright": "&>", + "below": "<<|", + "above": "|>>", + "overbelow": "&<|", + "overabove": "|&>", + "front": "<>", + "overfront": "&", + "tEq": "#=", + "tNe": "#<>", + "tLt": "#<", + "tLe": "#<=", + "tGt": "#>", + "tGe": "#>=", + "eEq": "?=", + "eNe": "?<>", + "eLt": "?<", + "eLe": "?<=", + "eGt": "?>", + "eGe": "?>=", + "aEq": "%=", + "aNe": "%<>", + "aLt": "%<", + "aLe": "%<=", + "aGt": "%>", + "aGe": "%>=", + "tDistance": "<->", + "nearestApproachDistance": "|=|", + "same": "~=" + }, + "bareNames": [ + "aEq", + "aGe", + "aGt", + "aLe", + "aLt", + "aNe", + "above", + "adjacent", + "after", + "back", + "before", + "below", + "contained", + "contains", + "eEq", + "eGe", + "eGt", + "eLe", + "eLt", + "eNe", + "front", + "left", + "nearestApproachDistance", + "overabove", + "overafter", + "overback", + "overbefore", + "overbelow", + "overfront", + "overlaps", + "overleft", + "overright", + "right", + "same", + "tDistance", + "tEq", + "tGe", + "tGt", + "tLe", + "tLt", + "tNe" + ], + "count": 41 + } +} \ No newline at end of file