diff --git a/.github/workflows/generate.yml b/.github/workflows/generate.yml new file mode 100644 index 00000000..14987dc7 --- /dev/null +++ b/.github/workflows/generate.yml @@ -0,0 +1,72 @@ +# +# Derives the MEOS catalog from MobilityDB in CI (instead of committing a +# meos-idl.json snapshot) and verifies that the committed generated UDF surface +# still matches a fresh derivation. This is the shared ecosystem model: bindings +# stop vendoring the catalog and derive it from one MobilityDB commit via the +# MEOS-API provision-meos action (the JMEOS/Spark/Flink/Kafka pattern). +# +name: Derive catalog and verify generated code + +on: + pull_request: + branches: + - main + - 'feat/**' + - 'fix/**' + paths-ignore: + - '**/README.md' + - 'doc/**' + push: + branches: + - main + paths-ignore: + - '**/README.md' + - 'doc/**' + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref || '' }} + cancel-in-progress: true + +jobs: + derive-and-verify: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + # The catalog is derived from the SAME MobilityDB commit the vcpkg MEOS + # port builds libmeos from, so the generated code always matches the + # libmeos it is compiled against. tools/meos-source-commit.txt is the + # single source of truth for that commit (the vcpkg portfile reads the same + # file), mirroring the shared ecosystem provision-meos model. + - name: Resolve the MobilityDB source commit + id: ref + run: echo "sha=$(tr -d '[:space:]' < tools/meos-source-commit.txt)" >> "$GITHUB_OUTPUT" + + # Generate meos-idl.json from that commit via the shared MEOS-API action. + # Catalog only (build-libmeos: false): the generator is pure Python and + # reads the catalog JSON, so no libmeos build is needed here. + - name: Provision the MEOS catalog + id: provision + uses: MobilityDB/MEOS-API/.github/actions/provision-meos@master + with: + mobilitydb-ref: ${{ steps.ref.outputs.sha }} + build-libmeos: "false" + + - name: Stage the catalog + run: | + mkdir -p tools/catalog + cp "${{ steps.provision.outputs.catalog-path }}" tools/catalog/meos-idl.json + + # Regenerate the committed UDF surface and fail if it drifts. The committed + # src/generated/*.cpp (compiled by the distribution pipeline) must always + # equal a fresh derivation from the current catalog. + - name: Regenerate and check for drift + run: | + python3 tools/codegen_duck_udfs.py \ + tools/catalog/meos-idl.json \ + src/generated/generated_temporal_udfs.cpp + if ! git diff --exit-code src/generated/; then + echo "::error::src/generated is stale — re-run tools/codegen_duck_udfs.py against a freshly derived catalog and commit the result" + exit 1 + fi diff --git a/.gitignore b/.gitignore index 225bf7aa..4f09bba8 100644 --- a/.gitignore +++ b/.gitignore @@ -5,7 +5,11 @@ duckdb_unittest_tempdir/ .DS_Store testext test/python/__pycache__/ +tools/__pycache__/ .Rhistory vcpkg/ *.log examples/quickstart/*.parquet + +# Derived in CI from MobilityDB via MEOS-API provision-meos (see .github/workflows/generate.yml); not vendored. +tools/catalog/meos-idl.json diff --git a/CMakeLists.txt b/CMakeLists.txt index 3ca9e2fe..e4b42e02 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,6 +37,23 @@ endif() # MEOS from overlay port find_package(MEOS CONFIG REQUIRED) +# H3 headers: the all-families libmeos exposes meos_h3.h, which includes +# . SIBLING-FROM MobilityDB CMakeLists.txt H3 block (find_path +# H3_INCLUDE_DIR NAMES h3api.h PATH_SUFFIXES h3) so code compiling against +# meos_h3.h sees the system libh3 headers, just as the meos port (-DH3=ON) does. +# The dir is attached to the extension targets below (mirroring the json-c +# block) because build_*_extension targets don't inherit directory includes. +# SIBLING-FROM MobilityDB CMakeLists.txt H3 block; NO_CMAKE_FIND_ROOT_PATH + explicit +# system PATHS are the binding-side adaptation: under the vcpkg toolchain find_path is +# confined to the vcpkg root and never sees the system /usr/include/h3 that libh3-dev ships. +find_path(H3_INCLUDE_DIR NAMES h3api.h + PATH_SUFFIXES h3 + PATHS /usr/include /usr/local/include + NO_CMAKE_FIND_ROOT_PATH) +if(NOT H3_INCLUDE_DIR) + message(FATAL_ERROR "h3api.h not found; install libh3-dev (the meos port is built with -DH3=ON).") +endif() + if(TARGET GEOS::geos_c) set(GEOS_TGT GEOS::geos_c) elseif(TARGET GEOS::geos) @@ -57,7 +74,9 @@ include_directories(duckdb-spatial/src/spatial) set(EXTENSION_SOURCES src/spatial_ref_sys_csv.inc - src/mobilityduck_extension.cpp + src/mobilityduck_extension.cpp + src/generated/generated_temporal_udfs.cpp + src/generated/generated_type_registration.cpp src/temporal/temporal.cpp src/temporal/temporal_functions.cpp src/temporal/temporal_aggregates.cpp @@ -89,6 +108,8 @@ set(EXTENSION_SOURCES src/geo/tgeogpoint.cpp src/geo/tgeogpoint_in_out.cpp src/geo/tgeogpoint_ops.cpp + src/quadbin/tquadbin.cpp + src/cbuffer/tcbuffer.cpp src/index/rtree_module.cpp src/single_tile_getters.cpp src/index/rtree_index_create_physical.cpp @@ -111,6 +132,11 @@ else() set(JSONC_TGT ${JSON-C_LIBRARIES}) endif() +# H3 headers for meos_h3.h (see the find_path above) — attached per-target like +# json-c, since build_*_extension targets don't inherit directory includes. +target_include_directories(${EXTENSION_NAME} PRIVATE ${H3_INCLUDE_DIR}) +target_include_directories(${LOADABLE_EXTENSION_NAME} PRIVATE ${H3_INCLUDE_DIR}) + # ----------------------------- # Link libraries # ----------------------------- diff --git a/Makefile b/Makefile index a9485498..63453c04 100644 --- a/Makefile +++ b/Makefile @@ -12,29 +12,39 @@ include extension-ci-tools/makefiles/duckdb_extension.Makefile # "TimeZone") to Europe/Brussels. Tests pass on any OS timezone — the # extension is the single source of truth, no TZ env var needed. # -# LoadInternal also calls ExtensionHelper::AutoLoadExtension(db, "icu") so -# the timezone option is honoured. Autoload looks for the extension on disk -# at $HOME/.duckdb/extensions///icu.duckdb_extension -# and falls back to a hub download. That fails both inside the linux_amd64 -# test docker container (empty path, no network egress) and on the macOS -# osx_arm64 test runner (hub icu not reliably resolvable). We copy the -# icu.duckdb_extension that was built locally as part of this extension's -# build (declared in extension_config.cmake) into the expected path, -# matched to the DuckDB platform string, before running the unittester. +# LoadInternal also auto-loads ICU so the named "Europe/Brussels" zone +# resolves. DuckDB autoloads ICU from +# $HOME/.duckdb/extensions///icu.duckdb_extension +# and otherwise falls back to a hub download — which fails inside the CI test +# docker (empty path, no network egress) and on the macOS osx_arm64 runner +# (hub ICU not reliably resolvable). So we stage the locally-built ICU into the +# expected path before the unittester runs. +# +# Target DuckDB is the v1.4.x LTS line, with later versions (v1.5.x) supported +# in a multi-version matrix the same way MobilityDB supports PostgreSQL 13-18 — +# so the staging path must NOT hardcode the version or platform. We derive both +# from the freshly-built duckdb binary (authoritative for whatever is being +# tested); DUCKDB_VERSION_TAG and the uname map are fallbacks only. DUCKDB_VERSION_TAG := v1.4.4 define stage_icu @if [ -f ./build/$(1)/extension/icu/icu.duckdb_extension ]; then \ - case "$$(uname -s)-$$(uname -m)" in \ - Linux-x86_64) platform=linux_amd64 ;; \ - Linux-aarch64) platform=linux_arm64 ;; \ - Darwin-arm64) platform=osx_arm64 ;; \ - Darwin-x86_64) platform=osx_amd64 ;; \ - *) platform=$$(uname -m) ;; \ - esac; \ - target=$$HOME/.duckdb/extensions/$(DUCKDB_VERSION_TAG)/$$platform; \ + duckdb_bin=./build/$(1)/duckdb; \ + version_tag=$$( [ -x "$$duckdb_bin" ] && "$$duckdb_bin" --version 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+' | head -1 ); \ + platform=$$( [ -x "$$duckdb_bin" ] && echo 'PRAGMA platform;' | "$$duckdb_bin" -noheader -list 2>/dev/null | tr -d '[:space:]' ); \ + [ -n "$$version_tag" ] || version_tag=$(DUCKDB_VERSION_TAG); \ + if [ -z "$$platform" ]; then \ + case "$$(uname -s)-$$(uname -m)" in \ + Linux-x86_64) platform=linux_amd64 ;; \ + Linux-aarch64) platform=linux_arm64 ;; \ + Darwin-arm64) platform=osx_arm64 ;; \ + Darwin-x86_64) platform=osx_amd64 ;; \ + *) platform=$$(uname -m) ;; \ + esac; \ + fi; \ + target=$$HOME/.duckdb/extensions/$$version_tag/$$platform; \ mkdir -p "$$target" && cp -f ./build/$(1)/extension/icu/icu.duckdb_extension "$$target/" && \ - echo "Staged icu.duckdb_extension at $$target/"; \ + echo "Staged icu.duckdb_extension at $$target/ (duckdb $$version_tag / $$platform)"; \ fi endef diff --git a/duckdb b/duckdb index 0b83e5d2..6ddac802 160000 --- a/duckdb +++ b/duckdb @@ -1 +1 @@ -Subproject commit 0b83e5d2f68bc02dfefde74b846bd039f078affa +Subproject commit 6ddac802ffa9bcfbcc3f5f0d71de5dff9b0bc250 diff --git a/src/cbuffer/tcbuffer.cpp b/src/cbuffer/tcbuffer.cpp new file mode 100644 index 00000000..1b6dcd6f --- /dev/null +++ b/src/cbuffer/tcbuffer.cpp @@ -0,0 +1,169 @@ +/* MobilityDuck binding for the MEOS circular-buffer types (cbuffer + tcbuffer). + * + * cbuffer is a varlena value (a point + a radius), surfaced as a BLOB. + * tcbuffer is the temporal circular buffer, stored as a Temporal* blob (BLOB). + * + * Only the type registration + text I/O boundary is hand-written here; the + * operation surface is generated from the MEOS-API catalog into src/generated/. + */ + +#include "cbuffer/tcbuffer.hpp" +#include "temporal/temporal.hpp" +#include "tydef.hpp" +#include "duckdb/common/types/data_chunk.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "mobilityduck/meos_exec_serial.hpp" +#include "time_util.hpp" + +extern "C" { + #include + #include + #include +} + +#include +#include +#include + +namespace duckdb { + +LogicalType CbufferTypes::cbuffer() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("cbuffer"); + return type; +} + +LogicalType CbufferTypes::tcbuffer() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("tcbuffer"); + return type; +} + +void CbufferTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType("cbuffer", cbuffer()); + loader.RegisterType("tcbuffer", tcbuffer()); +} + +namespace { + +/* cbuffer is a varlena value: the stored BLOB holds the full varlena bytes, so + * copy-in by the blob size and copy-out by VARSIZE_ANY. */ +inline Cbuffer *BlobToCbuffer(string_t blob) { + size_t sz = blob.GetSize(); + void *copy = malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} + +inline string_t CbufferToBlob(Vector &result, Cbuffer *cb) { + if (!cb) return string_t(); + /* Cbuffer is a 4-byte-header varlena (int32 vl_len_); VARSIZE reads it. */ + size_t sz = VARSIZE(cb); + string_t out = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(cb), sz)); + free(cb); + return out; +} + +inline Temporal *BlobToTemp(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *) malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} + +inline string_t TempToBlob(Vector &result, Temporal *t) { + if (!t) return string_t(); + size_t sz = temporal_mem_size(t); + string_t out = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return out; +} + +} // namespace + +/* ===================================================================== + * In / out — static cbuffer value + * ===================================================================== */ + +bool CbufferFunctions::Cbuffer_in_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t s) -> string_t { + std::string str(s.GetData(), s.GetSize()); + Cbuffer *cb = cbuffer_in(str.c_str()); + return CbufferToBlob(result, cb); + }); + return true; +} + +bool CbufferFunctions::Cbuffer_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t blob) -> string_t { + Cbuffer *cb = BlobToCbuffer(blob); + char *str = cbuffer_out(cb, OUT_DEFAULT_DECIMAL_DIGITS); + free(cb); + std::string copy(str); + free(str); + return StringVector::AddString(result, copy); + }); + return true; +} + +/* ===================================================================== + * In / out — tcbuffer temporal value + * ===================================================================== */ + +bool CbufferFunctions::Tcbuffer_in_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t s) -> string_t { + std::string str(s.GetData(), s.GetSize()); + Temporal *t = tcbuffer_in(str.c_str()); + return TempToBlob(result, t); + }); + return true; +} + +bool CbufferFunctions::Tcbuffer_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t blob) -> string_t { + Temporal *t = BlobToTemp(blob); + char *str = temporal_out(t, OUT_DEFAULT_DECIMAL_DIGITS); + free(t); + std::string copy(str); + free(str); + return StringVector::AddString(result, copy); + }); + return true; +} + +/* ===================================================================== + * Registration + * ===================================================================== */ + +void CbufferTypes::RegisterCastFunctions(ExtensionLoader &loader) { + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, cbuffer(), + CbufferFunctions::Cbuffer_in_cast); + RegisterMeosCastFunction(loader, cbuffer(), LogicalType::VARCHAR, + CbufferFunctions::Cbuffer_out_cast); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, tcbuffer(), + CbufferFunctions::Tcbuffer_in_cast); + RegisterMeosCastFunction(loader, tcbuffer(), LogicalType::VARCHAR, + CbufferFunctions::Tcbuffer_out_cast); +} + +} // namespace duckdb diff --git a/src/generated/generated_temporal_udfs.cpp b/src/generated/generated_temporal_udfs.cpp new file mode 100644 index 00000000..c6b2e685 --- /dev/null +++ b/src/generated/generated_temporal_udfs.cpp @@ -0,0 +1,18001 @@ +// GENERATED by tools/codegen_duck_udfs.py from the MEOS-API catalog — DO NOT EDIT. +#include "meos_wrapper_simple.hpp" +#include "common.hpp" +#include "temporal/temporal.hpp" +#include "temporal/temporal_functions.hpp" +#include "temporal/set.hpp" +#include "temporal/span.hpp" +#include "temporal/spanset.hpp" +#include "temporal/tbox.hpp" +#include "geo/stbox.hpp" +#include "geo/tgeompoint.hpp" +#include "geo/tgeogpoint.hpp" +#include "geo/tgeometry.hpp" +#include "geo/tgeography.hpp" +#include "cbuffer/tcbuffer.hpp" +#include "spatial/spatial_types.hpp" +#include "geo_util.hpp" +#include "meos_internal.h" +#include "meos_geo.h" +#include "meos_internal_geo.h" +#include "time_util.hpp" +#include "mobilityduck/meos_exec_serial.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/vector_operations/unary_executor.hpp" +#include "duckdb/common/vector_operations/binary_executor.hpp" +#include "duckdb/common/vector_operations/ternary_executor.hpp" +#include +#include + +namespace duckdb { +namespace { +// Self-contained blob<->Temporal marshalling (generated owns it; no hand-header dep). +inline string_t TemporalToBlob(Vector &result, Temporal *t) { + size_t sz = temporal_mem_size(t); + string_t out = StringVector::AddStringOrBlob(result, (const char *)t, sz); + free(t); + return out; +} +// Null-aware variants: a MEOS function returning NULL (empty/undefined result, +// e.g. an intersection or restriction with no match) maps to SQL NULL via the mask. +inline string_t TemporalToBlobN(Vector &result, Temporal *t, ValidityMask &mask, idx_t idx) { + if (!t) { mask.SetInvalid(idx); return string_t(); } + return TemporalToBlob(result, t); +} +inline Temporal *BlobToTemporal(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} +// Array-of-temporal (LIST(blob)) INPUT marshalling for the NxN set-set functions +// (minDistance(tgeo[],tgeo[]) etc.). Reads a DuckDB LIST row's child BLOBs into a fresh +// Temporal** (each element malloc'd by BlobToTemporal); the caller frees via FreeTemporalArr. +inline const Temporal **ListToTemporalArr(Vector &child, list_entry_t le, int *count) { + auto data = FlatVector::GetData(child); + int n = (int) le.length; + const Temporal **arr = (const Temporal **) malloc(sizeof(Temporal *) * (n > 0 ? n : 1)); + for (idx_t i = 0; i < le.length; i++) arr[i] = BlobToTemporal(data[le.offset + i]); + *count = n; + return arr; +} +inline void FreeTemporalArr(const Temporal **arr, int n) { + for (int i = 0; i < n; i++) free((void *) arr[i]); + free((void *) arr); +} +// Self-contained blob<->Set marshalling (hand binding's exact method: set_mem_size out). +inline string_t SetToBlob(Vector &result, Set *s) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)s, set_mem_size(s)); + free(s); + return out; +} +inline string_t SetToBlobN(Vector &result, Set *s, ValidityMask &mask, idx_t idx) { + if (!s) { mask.SetInvalid(idx); return string_t(); } + return SetToBlob(result, s); +} +inline Set *BlobToSet(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} +// Self-contained blob<->Span marshalling (Span is a FIXED-size struct -> sizeof(Span)). +inline string_t SpanToBlob(Vector &result, Span *s) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)s, sizeof(Span)); + free(s); + return out; +} +inline Span *BlobToSpan(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} +// Self-contained blob<->SpanSet marshalling (varlena -> spanset_mem_size out). +inline string_t SpanSetToBlob(Vector &result, SpanSet *ss) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)ss, spanset_mem_size(ss)); + free(ss); + return out; +} +inline SpanSet *BlobToSpanSet(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} +// Self-contained blob<->Cbuffer marshalling. Cbuffer is a 4-byte-header varlena +// (int32 vl_len_ + point + radius) -> VARSIZE out; the stored BLOB is the raw bytes. +inline string_t CbufferToBlob(Vector &result, Cbuffer *cb) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)cb, VARSIZE(cb)); + free(cb); + return out; +} +inline string_t CbufferToBlobN(Vector &result, Cbuffer *cb, ValidityMask &mask, idx_t idx) { + if (!cb) { mask.SetInvalid(idx); return string_t(); } + return CbufferToBlob(result, cb); +} +inline Cbuffer *BlobToCbuffer(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} +// Self-contained blob<->STBox/TBox marshalling (FIXED-size structs -> sizeof). +inline string_t StboxToBlob(Vector &result, STBox *b) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(STBox)); + free(b); + return out; +} +inline STBox *BlobToStbox(string_t blob) { + uint8_t *copy = (uint8_t *)malloc(blob.GetSize()); + memcpy(copy, blob.GetData(), blob.GetSize()); + return reinterpret_cast(copy); +} +inline string_t TboxToBlob(Vector &result, TBox *b) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(TBox)); + free(b); + return out; +} +inline TBox *BlobToTbox(string_t blob) { + uint8_t *copy = (uint8_t *)malloc(blob.GetSize()); + memcpy(copy, blob.GetData(), blob.GetSize()); + return reinterpret_cast(copy); +} +// Build a MEOS text* varlena from a DuckDB VARCHAR (hand binding's exact method); caller frees. +inline text *MakeText(string_t s) { + size_t len = s.GetSize(); + text *t = (text *)malloc(VARHDRSZ + len); + SET_VARSIZE(t, VARHDRSZ + len); + memcpy(VARDATA(t), s.GetData(), len); + return t; +} +// Convert an owned MEOS Interval* to a DuckDB interval_t and free it. +inline interval_t TakeInterval(MeosInterval *iv) { + interval_t out = IntervalToIntervalt(iv); + free(iv); + return out; +} +// MEOS TimestampTz (PG epoch micros) -> DuckDB timestamp_tz_t. +inline timestamp_tz_t TakeTimestamp(TimestampTz r) { + timestamp_tz_t ts; ts.value = (int64_t) r; return MeosToDuckDBTimestamp(ts); +} +// Owned MEOS text* varlena -> DuckDB VARCHAR string_t; frees the text*. +inline string_t TakeText(Vector &result, text *t) { + string_t out = StringVector::AddString(result, (const char *) VARDATA(t), VARSIZE(t) - VARHDRSZ); + free(t); + return out; +} +// Owned MEOS C-string (NUL-terminated, malloc'd) -> DuckDB VARCHAR; frees it. +inline string_t TakeCString(Vector &result, char *s) { + string_t out = StringVector::AddString(result, s); + free(s); + return out; +} + + +// ===== @ingroup meos_box_bbox_pos ===== +static void Gen_after_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = after_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_before_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = before_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_left_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = left_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overafter_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = overafter_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overbefore_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = overbefore_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overleft_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = overleft_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overright_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = overright_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_right_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = right_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_box_bbox_topo ===== +static void Gen_adjacent_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = adjacent_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = contained_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contains_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = contains_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overlaps_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = overlaps_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_same_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = same_tbox_tbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_box_comp ===== +static void Gen_tbox_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_eq(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_tbox_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_ge(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_tbox_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_gt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_tbox_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_le(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_tbox_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_lt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_tbox_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + bool r = tbox_ne(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_box_set ===== +static void Gen_intersection_tbox_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + TBox *s1 = BlobToTbox(a); + TBox *s2 = BlobToTbox(b); + TBox *r = intersection_tbox_tbox(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return TboxToBlob(result, r); + }); +} + + +// ===== @ingroup meos_cbuffer_accessor ===== +static void Gen_tcbuffer_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer * r = tcbuffer_end_value(t); + free(t); + return CbufferToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcbuffer_convex_hull(DataChunk &args, ExpressionState &state, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + GSERIALIZED * r = tcbuffer_convex_hull(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + string_t out = GSerializedToGeometry(r, state, result); + free(r); + return out; + }); +} + +static void Gen_tcbuffer_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer * r = tcbuffer_start_value(t); + free(t); + return CbufferToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_comp_ever ===== +static void Gen_always_eq_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = always_eq_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_eq_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_ne_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = always_ne_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_ne_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_eq_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = ever_eq_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_eq_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_ne_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = ever_ne_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_ne_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + + +// ===== @ingroup meos_cbuffer_comp_temp ===== +static void Gen_teq_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = teq_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tne_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_conversion ===== +static void Gen_tcbuffer_to_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tcbuffer_to_tfloat(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcbuffer_to_tgeompoint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tcbuffer_to_tgeompoint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeometry_to_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeometry_to_tcbuffer(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_dist ===== +static void Gen_tdistance_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tdistance_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdistance_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdistance_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdistance_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdistance_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_nad_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + double r = nad_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return r; + }); +} + +static void Gen_nad_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = nad_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_nai_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = (Temporal *) nai_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_rel_ever ===== +static void Gen_acovers_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = acovers_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_adisjoint_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adisjoint_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adisjoint_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = adisjoint_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_adisjoint_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = adisjoint_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_adwithin_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adwithin_tcbuffer_geo(t, gs, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adwithin_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::Execute(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = adwithin_tcbuffer_tcbuffer(t1, t2, a2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_aintersects_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = aintersects_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_aintersects_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = aintersects_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_aintersects_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = aintersects_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_atouches_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = atouches_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_atouches_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = atouches_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_econtains_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = econtains_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_econtains_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = econtains_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ecovers_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ecovers_geo_tcbuffer(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ecovers_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = ecovers_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_ecovers_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ecovers_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edisjoint_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edisjoint_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edisjoint_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = edisjoint_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_edwithin_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edwithin_tcbuffer_geo(t, gs, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edwithin_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::Execute(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = edwithin_tcbuffer_tcbuffer(t1, t2, a2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_eintersects_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = eintersects_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_eintersects_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = eintersects_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + +static void Gen_eintersects_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = eintersects_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_etouches_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = etouches_tcbuffer_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_etouches_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + int32_t r = etouches_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return (r != 0); + }); +} + + +// ===== @ingroup meos_cbuffer_rel_temp ===== +static void Gen_tcontains_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcontains_geo_tcbuffer(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcontains_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcontains_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcontains_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tcontains_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcontains_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tcontains_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcovers_geo_tcbuffer(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcovers_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tcovers_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tcovers_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_g, string_t in_t, double d, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdwithin_geo_tcbuffer(gs, t, d); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdwithin_tcbuffer_geo(t, gs, d); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdwithin_tcbuffer_tcbuffer(t1, t2, a2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdisjoint_geo_tcbuffer(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdisjoint_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tdisjoint_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdisjoint_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tintersects_geo_tcbuffer(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tintersects_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tintersects_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tintersects_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_geo_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = ttouches_geo_tcbuffer(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_tcbuffer_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = ttouches_tcbuffer_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_tcbuffer_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = ttouches_tcbuffer_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = ttouches_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_restrict ===== +static void Gen_tcbuffer_at_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tcbuffer_at_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcbuffer_at_geom(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcbuffer_at_geom(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcbuffer_minus_cbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Cbuffer *a2p = BlobToCbuffer(a2); + Temporal *r = tcbuffer_minus_cbuffer(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcbuffer_minus_geom(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcbuffer_minus_geom(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_cbuffer_transf ===== +static void Gen_tcbuffer_expand(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tcbuffer_expand(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_geo_accessor ===== +static void Gen_tpoint_angular_difference(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_angular_difference(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_azimuth(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_azimuth(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_cumulative_length(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_cumulative_length(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_get_x(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_get_x(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_get_y(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_get_y(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_get_z(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_get_z(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_is_simple(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + bool r = tpoint_is_simple(t); + free(t); + return r; + }); +} + +static void Gen_tpoint_length(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tpoint_length(t); + free(t); + return r; + }); +} + +static void Gen_tpoint_speed(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tpoint_speed(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_geo_bbox_pos ===== +static void Gen_above_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = above_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_after_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = after_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_back_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = back_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_before_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = before_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_below_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = below_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_front_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = front_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_left_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = left_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overabove_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overabove_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overafter_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overafter_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overback_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overback_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overbefore_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overbefore_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overbelow_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overbelow_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overfront_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overfront_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overleft_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overleft_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overright_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overright_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_right_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = right_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_above_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = above_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_above_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = above_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_after_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = after_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_after_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = after_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_back_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = back_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_back_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = back_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_before_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = before_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_before_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = before_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_below_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = below_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_below_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = below_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_front_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = front_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_front_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = front_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_left_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = left_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_left_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = left_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overabove_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overabove_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overabove_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overabove_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overafter_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overafter_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overafter_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overafter_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overback_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overback_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overback_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overback_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overbefore_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overbefore_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overbefore_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overbefore_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overbelow_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overbelow_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overbelow_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overbelow_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overfront_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overfront_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overfront_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overfront_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overleft_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overleft_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overleft_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overleft_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overright_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overright_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overright_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overright_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_right_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = right_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_right_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = right_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + + +// ===== @ingroup meos_geo_bbox_topo ===== +static void Gen_adjacent_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = adjacent_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contained_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contained_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contains_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contains_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overlaps_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overlaps_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_same_tspatial_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = same_tspatial_tspatial(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_adjacent_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = adjacent_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_adjacent_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = adjacent_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_contained_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = contained_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_contained_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = contained_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_contains_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = contains_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_contains_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = contains_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overlaps_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overlaps_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overlaps_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = overlaps_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_same_stbox_tspatial(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *bx = BlobToStbox(a); + Temporal *t = BlobToTemporal(b); + bool r = same_stbox_tspatial(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_same_tspatial_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + STBox *bx = BlobToStbox(b); + bool r = same_tspatial_stbox(t, bx); + free(t); free(bx); + return r; + }); +} + + +// ===== @ingroup meos_geo_box_comp ===== +static void Gen_stbox_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_eq(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_stbox_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_ge(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_stbox_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_gt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_stbox_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_le(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_stbox_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_lt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_stbox_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = stbox_ne(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_geo_box_pos ===== +static void Gen_above_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = above_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_after_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = after_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_back_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = back_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_before_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = before_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_below_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = below_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_front_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = front_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_left_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = left_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overabove_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overabove_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overafter_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overafter_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overback_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overback_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overbefore_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overbefore_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overbelow_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overbelow_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overfront_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overfront_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overleft_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overleft_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overright_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overright_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_right_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = right_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_geo_box_set ===== +static void Gen_intersection_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + STBox *r = intersection_stbox_stbox(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return StboxToBlob(result, r); + }); +} + + +// ===== @ingroup meos_geo_box_topo ===== +static void Gen_adjacent_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = adjacent_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = contained_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contains_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = contains_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overlaps_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = overlaps_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_same_stbox_stbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + STBox *s1 = BlobToStbox(a); + STBox *s2 = BlobToStbox(b); + bool r = same_stbox_stbox(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_geo_comp_ever ===== +static void Gen_always_eq_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = always_eq_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_always_eq_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = always_eq_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_always_eq_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_eq_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_ne_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = always_ne_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_always_ne_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = always_ne_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_always_ne_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_ne_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_eq_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ever_eq_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ever_eq_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ever_eq_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ever_eq_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_eq_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_ne_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ever_ne_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ever_ne_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ever_ne_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ever_ne_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_ne_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + + +// ===== @ingroup meos_geo_comp_temp ===== +static void Gen_teq_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = teq_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = teq_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tne_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tne_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_geo_conversion ===== +static void Gen_tgeogpoint_to_tgeography(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeogpoint_to_tgeography(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeography_to_tgeogpoint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeography_to_tgeogpoint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeography_to_tgeometry(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeography_to_tgeometry(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeometry_to_tgeography(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeometry_to_tgeography(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeometry_to_tgeompoint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeometry_to_tgeompoint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgeompoint_to_tgeometry(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgeompoint_to_tgeometry(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_geo_distance ===== +static void Gen_tdistance_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdistance_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdistance_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdistance_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_nad_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = nad_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_mindistance_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + BinaryExecutor::Execute( + lv1, lv2, result, args.size(), + [&](list_entry_t le1, list_entry_t le2) -> double { + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1, &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2, &n2); + double r = mindistance_tgeoarr_tgeoarr(a1, n1, a2, n2); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + return r; + }); +} + + +// ===== @ingroup meos_geo_inout ===== +static void Gen_tspatial_as_ewkt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + char * r = tspatial_as_ewkt(t, a2); + free(t); + return TakeCString(result, r); + }); +} + +static void Gen_tspatial_as_ewkt_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + char * r = tspatial_as_ewkt(t, 15); + free(t); + return TakeCString(result, r); + }); +} + +static void Gen_tspatial_as_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + char * r = tspatial_as_text(t, a2); + free(t); + return TakeCString(result, r); + }); +} + +static void Gen_tspatial_as_text_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + char * r = tspatial_as_text(t, 15); + free(t); + return TakeCString(result, r); + }); +} + + +// ===== @ingroup meos_geo_rel_ever ===== +static void Gen_acontains_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = acontains_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_acontains_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = acontains_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_acovers_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = acovers_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_acovers_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = acovers_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_acovers_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = acovers_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_adisjoint_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adisjoint_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adisjoint_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adisjoint_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = adisjoint_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_adwithin_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_g, string_t in_t, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adwithin_geo_tgeo(gs, t, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adwithin_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = adwithin_tgeo_geo(t, gs, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_adwithin_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::Execute(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = adwithin_tgeo_tgeo(t1, t2, a2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_aintersects_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = aintersects_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_aintersects_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = aintersects_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_aintersects_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = aintersects_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_atouches_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = atouches_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_atouches_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = atouches_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_atouches_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = atouches_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_atouches_geo_tpoint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = atouches_geo_tpoint(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_econtains_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = econtains_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_econtains_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = econtains_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_econtains_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = econtains_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ecovers_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ecovers_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ecovers_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = ecovers_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_ecovers_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ecovers_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_edisjoint_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edisjoint_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edisjoint_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edisjoint_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = edisjoint_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_edwithin_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_g, string_t in_t, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edwithin_geo_tgeo(gs, t, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edwithin_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = edwithin_tgeo_geo(t, gs, d); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edwithin_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::Execute(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = edwithin_tgeo_tgeo(t1, t2, a2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_eintersects_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = eintersects_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_eintersects_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = eintersects_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_eintersects_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = eintersects_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_etouches_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = etouches_geo_tgeo(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_etouches_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = etouches_tgeo_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_etouches_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = etouches_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_etouches_geo_tpoint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = etouches_geo_tpoint(gs, t); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_edwithin_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + args.data[2].Flatten(row_count); + auto dd = FlatVector::GetData(args.data[2]); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = edwithin_tgeoarr_tgeoarr(a1, n1, a2, n2, dd[r], &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_adwithin_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + args.data[2].Flatten(row_count); + auto dd = FlatVector::GetData(args.data[2]); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = adwithin_tgeoarr_tgeoarr(a1, n1, a2, n2, dd[r], &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_eintersects_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = eintersects_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_aintersects_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = aintersects_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_etouches_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = etouches_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_atouches_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = atouches_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_edisjoint_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = edisjoint_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_adisjoint_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + int *res = adisjoint_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + } + off += n; + } + if (res) free(res); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_acovers_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = acovers_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ecovers_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ecovers_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_etouches_tcbuffer_tcbuffer(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = etouches_tcbuffer_tcbuffer(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + + +// ===== @ingroup meos_geo_rel_temp ===== +static void Gen_tcontains_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcontains_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcontains_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcontains_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcontains_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tcontains_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcovers_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tcovers_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tcovers_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tcovers_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdisjoint_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdisjoint_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdisjoint_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_g, string_t in_t, double d, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdwithin_geo_tgeo(gs, t, d); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in_t, string_t in_g, double d, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tdwithin_tgeo_geo(t, gs, d); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdwithin_tgeo_tgeo(t1, t2, a2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tintersects_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tintersects_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tintersects_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tintersects_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_geo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_g, string_t in_t, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = ttouches_geo_tgeo(gs, t); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_tgeo_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = ttouches_tgeo_geo(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttouches_tgeo_tgeo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = ttouches_tgeo_tgeo(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdwithin_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + args.data[2].Flatten(row_count); + auto dd = FlatVector::GetData(args.data[2]); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + SpanSet **periods = nullptr; + int *res = tdwithin_tgeoarr_tgeoarr(a1, n1, a2, n2, dd[r], &cnt, &periods); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + auto &pv = *sf[2]; + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + FlatVector::GetData(pv)[off + k] = SpanSetToBlob(pv, periods[k]); + } + off += n; + } + if (res) free(res); + if (periods) free(periods); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_tintersects_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + SpanSet **periods = nullptr; + int *res = tintersects_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt, &periods); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + auto &pv = *sf[2]; + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + FlatVector::GetData(pv)[off + k] = SpanSetToBlob(pv, periods[k]); + } + off += n; + } + if (res) free(res); + if (periods) free(periods); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_ttouches_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + SpanSet **periods = nullptr; + int *res = ttouches_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt, &periods); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + auto &pv = *sf[2]; + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + FlatVector::GetData(pv)[off + k] = SpanSetToBlob(pv, periods[k]); + } + off += n; + } + if (res) free(res); + if (periods) free(periods); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + +static void Gen_tdisjoint_tgeoarr_tgeoarr(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + idx_t row_count = args.size(); + auto &lv1 = args.data[0]; auto &lv2 = args.data[1]; + lv1.Flatten(row_count); lv2.Flatten(row_count); + auto le1 = FlatVector::GetData(lv1); + auto le2 = FlatVector::GetData(lv2); + auto &v1 = FlatVector::Validity(lv1); + auto &v2 = FlatVector::Validity(lv2); + auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1)); + auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2)); + auto list_entries = FlatVector::GetData(result); + auto &result_validity = FlatVector::Validity(result); + idx_t off = 0; + for (idx_t r = 0; r < row_count; r++) { + if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) { + result_validity.SetInvalid(r); list_entries[r] = list_entry_t{off, 0}; continue; + } + int n1, n2; + const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1); + const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2); + int cnt = 0; + SpanSet **periods = nullptr; + int *res = tdisjoint_tgeoarr_tgeoarr(a1, n1, a2, n2, &cnt, &periods); + FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2); + int n = (res && cnt > 0) ? cnt : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[r] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &sv = ListVector::GetEntry(result); + auto &sf = StructVector::GetEntries(sv); + auto id = FlatVector::GetData(*sf[0]); + auto jd = FlatVector::GetData(*sf[1]); + auto &pv = *sf[2]; + for (int k = 0; k < n; k++) { + id[off + k] = res[2 * k]; + jd[off + k] = res[2 * k + 1]; + FlatVector::GetData(pv)[off + k] = SpanSetToBlob(pv, periods[k]); + } + off += n; + } + if (res) free(res); + if (periods) free(periods); + result_validity.SetValid(r); + } + if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR); +} + + +// ===== @ingroup meos_geo_restrict ===== +static void Gen_tpoint_at_geom(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tpoint_at_geom(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_at_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tpoint_at_value(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_minus_geom(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tpoint_minus_geom(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpoint_minus_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + Temporal *r = tpoint_minus_value(t, gs); + free(t); free(gs); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_geo_srid ===== +static void Gen_tspatial_srid(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = tspatial_srid(t); + free(t); + return r; + }); +} + +static void Gen_tspatial_set_srid(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tspatial_set_srid(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tspatial_transform(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tspatial_transform(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_internal_temporal_inout ===== +static void Gen_temporal_from_mfjson(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *r = temporal_from_mfjson(in.GetString().c_str(), temptype); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_quadbin_conversion ===== +static void Gen_tbigint_to_tquadbin(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_to_tquadbin(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tquadbin_to_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tquadbin_to_tbigint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_setspan_accessor ===== +static void Gen_bigintset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int64_t r = bigintset_end_value(s); + free(s); + return r; + }); +} + +static void Gen_bigintset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int64_t r = bigintset_start_value(s); + free(s); + return r; + }); +} + +static void Gen_dateset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + DateADT r = dateset_end_value(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_dateset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + DateADT r = dateset_start_value(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_floatset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + double r = floatset_end_value(s); + free(s); + return r; + }); +} + +static void Gen_floatset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + double r = floatset_start_value(s); + free(s); + return r; + }); +} + +static void Gen_intset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int32_t r = intset_end_value(s); + free(s); + return r; + }); +} + +static void Gen_intset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int32_t r = intset_start_value(s); + free(s); + return r; + }); +} + +static void Gen_set_hash(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int32_t r = set_hash(s); + free(s); + return r; + }); +} + +static void Gen_set_num_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + int32_t r = set_num_values(s); + free(s); + return r; + }); +} + +static void Gen_textset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + text * r = textset_end_value(s); + free(s); + return TakeText(result, r); + }); +} + +static void Gen_textset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + text * r = textset_start_value(s); + free(s); + return TakeText(result, r); + }); +} + +static void Gen_tstzset_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + TimestampTz r = tstzset_end_value(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_tstzset_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Set *s = BlobToSet(in); + TimestampTz r = tstzset_start_value(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_bigintset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + int64_t * arr = bigintset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = arr[j]; } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_dateset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + DateADT * arr = dateset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = FromMeosDate((int32_t) arr[j]); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_floatset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + double * arr = floatset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = arr[j]; } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_intset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + int * arr = intset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = arr[j]; } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_textset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + text ** arr = textset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = TakeText(child_vector, arr[j]); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_tstzset_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + TimestampTz * arr = tstzset_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = TakeTimestamp(arr[j]); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_bigintspan_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int64_t r = bigintspan_lower(s); + free(s); + return r; + }); +} + +static void Gen_bigintspan_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int64_t r = bigintspan_upper(s); + free(s); + return r; + }); +} + +static void Gen_bigintspan_width(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int64_t r = bigintspan_width(s); + free(s); + return r; + }); +} + +static void Gen_datespan_duration(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + MeosInterval * r = datespan_duration(s); + free(s); + return TakeInterval(r); + }); +} + +static void Gen_datespan_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + DateADT r = datespan_lower(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_datespan_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + DateADT r = datespan_upper(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_floatspan_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + double r = floatspan_lower(s); + free(s); + return r; + }); +} + +static void Gen_floatspan_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + double r = floatspan_upper(s); + free(s); + return r; + }); +} + +static void Gen_floatspan_width(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + double r = floatspan_width(s); + free(s); + return r; + }); +} + +static void Gen_intspan_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int32_t r = intspan_lower(s); + free(s); + return r; + }); +} + +static void Gen_intspan_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int32_t r = intspan_upper(s); + free(s); + return r; + }); +} + +static void Gen_intspan_width(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int32_t r = intspan_width(s); + free(s); + return r; + }); +} + +static void Gen_span_hash(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + int32_t r = span_hash(s); + free(s); + return r; + }); +} + +static void Gen_span_lower_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + bool r = span_lower_inc(s); + free(s); + return r; + }); +} + +static void Gen_span_upper_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + bool r = span_upper_inc(s); + free(s); + return r; + }); +} + +static void Gen_tstzspan_duration(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + MeosInterval * r = tstzspan_duration(s); + free(s); + return TakeInterval(r); + }); +} + +static void Gen_tstzspan_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + TimestampTz r = tstzspan_lower(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_tstzspan_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Span *s = BlobToSpan(in); + TimestampTz r = tstzspan_upper(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_bigintspanset_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int64_t r = bigintspanset_lower(s); + free(s); + return r; + }); +} + +static void Gen_bigintspanset_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int64_t r = bigintspanset_upper(s); + free(s); + return r; + }); +} + +static void Gen_datespanset_duration(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + SpanSet *s = BlobToSpanSet(in); + MeosInterval *r = datespanset_duration(s, a2); + free(s); + return TakeInterval(r); + }); +} + +static void Gen_datespanset_end_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + DateADT r = datespanset_end_date(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_datespanset_num_dates(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = datespanset_num_dates(s); + free(s); + return r; + }); +} + +static void Gen_datespanset_start_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + DateADT r = datespanset_start_date(s); + free(s); + return FromMeosDate((int32_t) r); + }); +} + +static void Gen_floatspanset_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + double r = floatspanset_lower(s); + free(s); + return r; + }); +} + +static void Gen_floatspanset_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + double r = floatspanset_upper(s); + free(s); + return r; + }); +} + +static void Gen_intspanset_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = intspanset_lower(s); + free(s); + return r; + }); +} + +static void Gen_intspanset_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = intspanset_upper(s); + free(s); + return r; + }); +} + +static void Gen_spanset_hash(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = spanset_hash(s); + free(s); + return r; + }); +} + +static void Gen_spanset_lower_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + bool r = spanset_lower_inc(s); + free(s); + return r; + }); +} + +static void Gen_spanset_num_spans(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = spanset_num_spans(s); + free(s); + return r; + }); +} + +static void Gen_spanset_upper_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + bool r = spanset_upper_inc(s); + free(s); + return r; + }); +} + +static void Gen_tstzspanset_duration(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + SpanSet *s = BlobToSpanSet(in); + MeosInterval *r = tstzspanset_duration(s, a2); + free(s); + return TakeInterval(r); + }); +} + +static void Gen_tstzspanset_end_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + TimestampTz r = tstzspanset_end_timestamptz(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_tstzspanset_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + TimestampTz r = tstzspanset_lower(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_tstzspanset_num_timestamps(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + int32_t r = tstzspanset_num_timestamps(s); + free(s); + return r; + }); +} + +static void Gen_tstzspanset_start_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + TimestampTz r = tstzspanset_start_timestamptz(s); + free(s); + return TakeTimestamp(r); + }); +} + +static void Gen_tstzspanset_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + SpanSet *s = BlobToSpanSet(in); + TimestampTz r = tstzspanset_upper(s); + free(s); + return TakeTimestamp(r); + }); +} + + +// ===== @ingroup meos_setspan_bbox_split ===== +static void Gen_set_spans(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Set *in = BlobToSet(blob); + int count = 0; + Span * arr = set_spans(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(Span)); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_spanset_spans(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + SpanSet *in = BlobToSpanSet(blob); + int count = 0; + Span * arr = spanset_spans(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(Span)); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + + +// ===== @ingroup meos_setspan_comp ===== +static void Gen_set_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_eq(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_set_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_ge(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_set_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_gt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_set_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_le(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_set_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_lt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_set_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = set_ne(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_eq(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_ge(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_gt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_le(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_lt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_span_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = span_ne(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_eq(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_ge(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_gt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_le(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_lt(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_spanset_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = spanset_ne(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_setspan_conversion ===== +static void Gen_dateset_to_tstzset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = dateset_to_tstzset(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_floatset_to_intset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = floatset_to_intset(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_intset_to_floatset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = intset_to_floatset(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tstzset_to_dateset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = tstzset_to_dateset(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_datespan_to_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = datespan_to_tstzspan(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_to_intspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_to_intspan(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_intspan_to_floatspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = intspan_to_floatspan(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_tstzspan_to_datespan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = tstzspan_to_datespan(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_datespanset_to_tstzspanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = datespanset_to_tstzspanset(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_to_intspanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_to_intspanset(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_intspanset_to_floatspanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = intspanset_to_floatspanset(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_tstzspanset_to_datespanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = tstzspanset_to_datespanset(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + + +// ===== @ingroup meos_setspan_inout ===== +static void Gen_set_from_hexwkb(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *r = set_from_hexwkb(in.GetString().c_str()); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_span_from_hexwkb(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *r = span_from_hexwkb(in.GetString().c_str()); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_spanset_from_hexwkb(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *r = spanset_from_hexwkb(in.GetString().c_str()); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + + +// ===== @ingroup meos_setspan_pos ===== +static void Gen_after_date_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = after_date_set(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_after_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + bool r = after_set_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_after_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + bool r = after_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_after_timestamptz_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = after_timestamptz_set(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_before_date_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = before_date_set(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_before_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + bool r = before_set_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_before_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + bool r = before_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_before_timestamptz_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = before_timestamptz_set(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_left_bigint_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = left_bigint_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_float_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Set *s = BlobToSet(b); + bool r = left_float_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_int_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = left_int_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + bool r = left_set_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + bool r = left_set_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + bool r = left_set_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = left_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_left_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + bool r = left_set_text(s, t2); + free(t2); free(s); + return r; + }); +} + +static void Gen_left_text_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t b) { + text *t1 = MakeText(a1); + Set *s = BlobToSet(b); + bool r = left_text_set(t1, s); + free(t1); free(s); + return r; + }); +} + +static void Gen_overafter_date_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overafter_date_set(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overafter_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + bool r = overafter_set_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overafter_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + bool r = overafter_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overafter_timestamptz_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overafter_timestamptz_set(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overbefore_date_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overbefore_date_set(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overbefore_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + bool r = overbefore_set_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overbefore_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + bool r = overbefore_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overbefore_timestamptz_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overbefore_timestamptz_set(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overleft_bigint_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overleft_bigint_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_float_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overleft_float_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_int_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overleft_int_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + bool r = overleft_set_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + bool r = overleft_set_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + bool r = overleft_set_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = overleft_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overleft_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + bool r = overleft_set_text(s, t2); + free(t2); free(s); + return r; + }); +} + +static void Gen_overleft_text_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t b) { + text *t1 = MakeText(a1); + Set *s = BlobToSet(b); + bool r = overleft_text_set(t1, s); + free(t1); free(s); + return r; + }); +} + +static void Gen_overright_bigint_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overright_bigint_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_float_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overright_float_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_int_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = overright_int_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + bool r = overright_set_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + bool r = overright_set_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + bool r = overright_set_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = overright_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overright_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + bool r = overright_set_text(s, t2); + free(t2); free(s); + return r; + }); +} + +static void Gen_overright_text_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t b) { + text *t1 = MakeText(a1); + Set *s = BlobToSet(b); + bool r = overright_text_set(t1, s); + free(t1); free(s); + return r; + }); +} + +static void Gen_right_bigint_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = right_bigint_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_float_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Set *s = BlobToSet(b); + bool r = right_float_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_int_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = right_int_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + bool r = right_set_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + bool r = right_set_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + bool r = right_set_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = right_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_right_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + bool r = right_set_text(s, t2); + free(t2); free(s); + return r; + }); +} + +static void Gen_right_text_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t b) { + text *t1 = MakeText(a1); + Set *s = BlobToSet(b); + bool r = right_text_set(t1, s); + free(t1); free(s); + return r; + }); +} + +static void Gen_after_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = after_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_after_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = after_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_after_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = after_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_after_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = after_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_before_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = before_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_before_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = before_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_before_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = before_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_before_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = before_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_left_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = left_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = left_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = left_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = left_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = left_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = left_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = left_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_left_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = left_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_left_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = left_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overafter_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overafter_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overafter_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = overafter_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overafter_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = overafter_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overafter_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overafter_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overbefore_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overbefore_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overbefore_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = overbefore_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overbefore_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = overbefore_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overbefore_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overbefore_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overleft_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overleft_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overleft_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overleft_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = overleft_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = overleft_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = overleft_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = overleft_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overleft_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = overleft_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overleft_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = overleft_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overright_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overright_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overright_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = overright_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = overright_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = overright_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = overright_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = overright_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overright_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = overright_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overright_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = overright_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_right_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = right_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = right_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = right_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = right_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = right_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = right_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = right_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_right_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = right_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_right_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = right_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_after_date_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = after_date_spanset(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_after_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = after_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_after_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = after_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_after_timestamptz_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = after_timestamptz_spanset(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_before_date_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = before_date_spanset(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_before_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = before_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_before_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = before_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_before_timestamptz_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = before_timestamptz_spanset(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_left_bigint_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = left_bigint_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_float_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = left_float_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_int_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = left_int_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_left_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = left_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = left_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = left_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_left_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = left_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overafter_date_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overafter_date_spanset(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overafter_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overafter_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overafter_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overafter_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overafter_timestamptz_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overafter_timestamptz_spanset(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overbefore_date_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overbefore_date_spanset(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_overbefore_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overbefore_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_overbefore_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overbefore_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overbefore_timestamptz_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overbefore_timestamptz_spanset(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_overleft_bigint_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overleft_bigint_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_float_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overleft_float_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_int_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overleft_int_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overleft_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overleft_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overleft_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overleft_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overleft_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = overleft_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overright_bigint_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overright_bigint_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_float_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overright_float_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_int_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = overright_int_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_overright_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overright_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overright_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = overright_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_overright_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = overright_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_right_bigint_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = right_bigint_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_float_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = right_float_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_int_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = right_int_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_right_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = right_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = right_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = right_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_right_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = right_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_setspan_set ===== +static void Gen_intersection_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + Set *r = intersection_set_bigint(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + Set *r = intersection_set_date(s, ToMeosDate(a2)); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + Set *r = intersection_set_float(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + Set *r = intersection_set_int(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + Set *r = intersection_set_set(s1, s2); + free(s1); free(s2); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_intersection_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + Set *r = intersection_set_text(s, t2); + free(t2); free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + Set *r = intersection_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + Set *r = minus_set_bigint(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + Set *r = minus_set_date(s, ToMeosDate(a2)); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + Set *r = minus_set_float(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + Set *r = minus_set_int(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + Set *r = minus_set_set(s1, s2); + free(s1); free(s2); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_minus_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + Set *r = minus_set_text(s, t2); + free(t2); free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_minus_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + Set *r = minus_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + Set *r = union_set_bigint(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + Set *r = union_set_date(s, ToMeosDate(a2)); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + Set *r = union_set_float(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + Set *r = union_set_int(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + Set *r = union_set_set(s1, s2); + free(s1); free(s2); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_union_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + Set *r = union_set_text(s, t2); + free(t2); free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_union_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + Set *r = union_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_intersection_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + Span *r = intersection_span_span(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_intersection_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + SpanSet *r = intersection_spanset_spanset(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_minus_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + SpanSet *r = minus_spanset_spanset(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_union_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + SpanSet *r = union_spanset_spanset(s1, s2); + free(s1); free(s2); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + + +// ===== @ingroup meos_setspan_topo ===== +static void Gen_contained_bigint_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = contained_bigint_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_date_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = contained_date_set(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_contained_float_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Set *s = BlobToSet(b); + bool r = contained_float_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_int_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = contained_int_set(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = contained_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_text_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t b) { + text *t1 = MakeText(a1); + Set *s = BlobToSet(b); + bool r = contained_text_set(t1, s); + free(t1); free(s); + return r; + }); +} + +static void Gen_contained_timestamptz_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Set *s = BlobToSet(b); + bool r = contained_timestamptz_set(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_contains_set_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Set *s = BlobToSet(a); + bool r = contains_set_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_set_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Set *s = BlobToSet(a); + bool r = contains_set_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_contains_set_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Set *s = BlobToSet(a); + bool r = contains_set_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_set_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + bool r = contains_set_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = contains_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contains_set_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + bool r = contains_set_text(s, t2); + free(t2); free(s); + return r; + }); +} + +static void Gen_contains_set_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Set *s = BlobToSet(a); + bool r = contains_set_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overlaps_set_set(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Set *s1 = BlobToSet(a); + Set *s2 = BlobToSet(b); + bool r = overlaps_set_set(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_adjacent_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = adjacent_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = adjacent_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_adjacent_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = adjacent_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = adjacent_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = adjacent_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_adjacent_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = adjacent_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_adjacent_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = adjacent_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_adjacent_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = adjacent_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_adjacent_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = adjacent_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_adjacent_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = adjacent_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_adjacent_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = adjacent_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_adjacent_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = adjacent_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = adjacent_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_contained_bigint_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = contained_bigint_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_date_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = contained_date_span(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_contained_float_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = contained_float_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_int_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = contained_int_span(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = contained_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = contained_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_contained_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = contained_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_contained_timestamptz_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + Span *s = BlobToSpan(b); + bool r = contained_timestamptz_span(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_contains_span_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + Span *s = BlobToSpan(a); + bool r = contains_span_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_span_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + Span *s = BlobToSpan(a); + bool r = contains_span_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_contains_span_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + Span *s = BlobToSpan(a); + bool r = contains_span_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_span_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Span *s = BlobToSpan(a); + bool r = contains_span_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = contains_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contains_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = contains_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_contains_span_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + Span *s = BlobToSpan(a); + bool r = contains_span_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = contains_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overlaps_span_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *s1 = BlobToSpan(a); + Span *s2 = BlobToSpan(b); + bool r = overlaps_span_span(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_overlaps_span_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *x = BlobToSpan(a); + SpanSet *y = BlobToSpanSet(b); + bool r = overlaps_span_spanset(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_overlaps_spanset_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *x = BlobToSpanSet(a); + Span *y = BlobToSpan(b); + bool r = overlaps_spanset_span(x, y); + free(x); free(y); + return r; + }); +} + +static void Gen_adjacent_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = adjacent_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = adjacent_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = adjacent_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = adjacent_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = adjacent_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_adjacent_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = adjacent_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_bigint_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = contained_bigint_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_date_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](date_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = contained_date_spanset(ToMeosDate(a1), s); + free(s); + return r; + }); +} + +static void Gen_contained_float_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = contained_float_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_int_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = contained_int_spanset(a1, s); + free(s); + return r; + }); +} + +static void Gen_contained_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = contained_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contained_timestamptz_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](timestamp_tz_t a1, string_t b) { + SpanSet *s = BlobToSpanSet(b); + bool r = contained_timestamptz_spanset(DuckDBToMeosTimestamp(a1).value, s); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int64_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = contains_spanset_bigint(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_date(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, date_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = contains_spanset_date(s, ToMeosDate(a2)); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, double a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = contains_spanset_float(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = contains_spanset_int(s, a2); + free(s); + return r; + }); +} + +static void Gen_contains_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = contains_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + +static void Gen_contains_spanset_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, timestamp_tz_t a2) { + SpanSet *s = BlobToSpanSet(a); + bool r = contains_spanset_timestamptz(s, DuckDBToMeosTimestamp(a2).value); + free(s); + return r; + }); +} + +static void Gen_overlaps_spanset_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + SpanSet *s1 = BlobToSpanSet(a); + SpanSet *s2 = BlobToSpanSet(b); + bool r = overlaps_spanset_spanset(s1, s2); + free(s1); free(s2); + return r; + }); +} + + +// ===== @ingroup meos_setspan_transf ===== +static void Gen_floatset_ceil(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = floatset_ceil(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_floatset_degrees(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, bool a2) { + Set *s = BlobToSet(a); + Set *r = floatset_degrees(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_floatset_degrees_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + Set *s = BlobToSet(a); + Set *r = floatset_degrees(s, false); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_floatset_floor(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = floatset_floor(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_floatset_radians(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = floatset_radians(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_set_round(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, int32_t a2) { + Set *s = BlobToSet(a); + Set *r = set_round(s, a2); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_set_round_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + Set *s = BlobToSet(a); + Set *r = set_round(s, 0); + free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_textcat_textset_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t a2) { + Set *s = BlobToSet(a); + text *t2 = MakeText(a2); + Set *r = textcat_textset_text(s, t2); + free(t2); free(s); + return SetToBlob(result, r); + }); +} + +static void Gen_textset_initcap(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = textset_initcap(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_textset_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = textset_lower(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_textset_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Set *s = BlobToSet(in); + Set *r = textset_upper(s); + free(s); + return SetToBlobN(result, r, mask, idx); + }); +} + +static void Gen_bigintspan_expand(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = bigintspan_expand(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_expand(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_expand(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_intspan_expand(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = intspan_expand(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_ceil(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_ceil(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_degrees(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_degrees(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_degrees_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + Span *s = BlobToSpan(a); + Span *r = floatspan_degrees(s, false); + free(s); + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_floor(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_floor(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_radians(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_radians(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_round(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Span *s = BlobToSpan(in); + Span *r = floatspan_round(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspan_round_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + Span *s = BlobToSpan(a); + Span *r = floatspan_round(s, 0); + free(s); + return SpanToBlob(result, r); + }); +} + +static void Gen_floatspanset_ceil(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_ceil(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_floor(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_floor(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_degrees(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_degrees(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_degrees_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + SpanSet *s = BlobToSpanSet(a); + SpanSet *r = floatspanset_degrees(s, false); + free(s); + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_radians(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_radians(s); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_round(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + SpanSet *s = BlobToSpanSet(in); + SpanSet *r = floatspanset_round(s, a2); + free(s); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanSetToBlob(result, r); + }); +} + +static void Gen_floatspanset_round_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t a) { + SpanSet *s = BlobToSpanSet(a); + SpanSet *r = floatspanset_round(s, 0); + free(s); + return SpanSetToBlob(result, r); + }); +} + + +// ===== @ingroup meos_temporal_accessor ===== +static void Gen_tbool_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + bool r = tbool_end_value(t); + free(t); + return r; + }); +} + +static void Gen_tbool_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + bool r = tbool_start_value(t); + free(t); + return r; + }); +} + +static void Gen_temporal_duration(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + Temporal *t = BlobToTemporal(in); + MeosInterval * r = temporal_duration(t, a2); + free(t); + return TakeInterval(r); + }); +} + +static void Gen_temporal_duration_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + MeosInterval * r = temporal_duration(t, false); + free(t); + return TakeInterval(r); + }); +} + +static void Gen_temporal_end_instant(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_end_instant(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_end_sequence(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_end_sequence(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_end_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + TimestampTz r = temporal_end_timestamptz(t); + free(t); + return TakeTimestamp(r); + }); +} + +static void Gen_temporal_hash(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = temporal_hash(t); + free(t); + return r; + }); +} + +static void Gen_temporal_instant_n(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_instant_n(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_interp(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + const char * r = temporal_interp(t); + free(t); + return StringVector::AddString(result, r); + }); +} + +static void Gen_temporal_lower_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + bool r = temporal_lower_inc(t); + free(t); + return r; + }); +} + +static void Gen_temporal_max_instant(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_max_instant(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_min_instant(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_min_instant(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_num_instants(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = temporal_num_instants(t); + free(t); + return r; + }); +} + +static void Gen_temporal_num_sequences(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = temporal_num_sequences(t); + free(t); + return r; + }); +} + +static void Gen_temporal_num_timestamps(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = temporal_num_timestamps(t); + free(t); + return r; + }); +} + +static void Gen_temporal_sequence_n(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_sequence_n(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_start_instant(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_start_instant(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_start_sequence(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_start_sequence(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_start_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + TimestampTz r = temporal_start_timestamptz(t); + free(t); + return TakeTimestamp(r); + }); +} + +static void Gen_temporal_subtype(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + const char * r = temporal_subtype(t); + free(t); + return StringVector::AddString(result, r); + }); +} + +static void Gen_temporal_basetype_name(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + const char * r = temporal_basetype_name(t); + free(t); + return StringVector::AddString(result, r); + }); +} + +static void Gen_temporal_upper_inc(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + bool r = temporal_upper_inc(t); + free(t); + return r; + }); +} + +static void Gen_tfloat_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tfloat_end_value(t); + free(t); + return r; + }); +} + +static void Gen_tfloat_min_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tfloat_min_value(t); + free(t); + return r; + }); +} + +static void Gen_tfloat_max_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tfloat_max_value(t); + free(t); + return r; + }); +} + +static void Gen_tfloat_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tfloat_start_value(t); + free(t); + return r; + }); +} + +static void Gen_tint_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = tint_end_value(t); + free(t); + return r; + }); +} + +static void Gen_tbigint_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int64_t r = tbigint_end_value(t); + free(t); + return r; + }); +} + +static void Gen_tint_max_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = tint_max_value(t); + free(t); + return r; + }); +} + +static void Gen_tbigint_max_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int64_t r = tbigint_max_value(t); + free(t); + return r; + }); +} + +static void Gen_tint_min_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = tint_min_value(t); + free(t); + return r; + }); +} + +static void Gen_tbigint_min_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int64_t r = tbigint_min_value(t); + free(t); + return r; + }); +} + +static void Gen_tint_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = tint_start_value(t); + free(t); + return r; + }); +} + +static void Gen_tbigint_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + int64_t r = tbigint_start_value(t); + free(t); + return r; + }); +} + +static void Gen_tnumber_integral(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tnumber_integral(t); + free(t); + return r; + }); +} + +static void Gen_tnumber_twavg(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + double r = tnumber_twavg(t); + free(t); + return r; + }); +} + +static void Gen_ttext_end_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + text * r = ttext_end_value(t); + free(t); + return TakeText(result, r); + }); +} + +static void Gen_ttext_max_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + text * r = ttext_max_value(t); + free(t); + return TakeText(result, r); + }); +} + +static void Gen_ttext_min_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + text * r = ttext_min_value(t); + free(t); + return TakeText(result, r); + }); +} + +static void Gen_ttext_start_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::Execute(args.data[0], result, args.size(), + [&](string_t in) { + Temporal *t = BlobToTemporal(in); + text * r = ttext_start_value(t); + free(t); + return TakeText(result, r); + }); +} + +static void Gen_tbool_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Temporal *in = BlobToTemporal(blob); + int count = 0; + bool * arr = tbool_values(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = arr[j]; } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_temporal_timestamps(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Temporal *in = BlobToTemporal(blob); + int count = 0; + TimestampTz * arr = temporal_timestamps(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = TakeTimestamp(arr[j]); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + + +// ===== @ingroup meos_temporal_analytics_similarity ===== +static void Gen_temporal_dyntimewarp_distance(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = temporal_dyntimewarp_distance(t1, t2); + free(t1); free(t2); + return r; + }); +} + +struct PathBind_temporal_dyntimewarp_path : public TableFunctionData { string_t a, b; }; +struct PathState_temporal_dyntimewarp_path : public GlobalTableFunctionState { + idx_t idx = 0; + std::vector col0; + std::vector col1; +}; +static unique_ptr PathBindFn_temporal_dyntimewarp_path(ClientContext &, TableFunctionBindInput &input, + vector &return_types, vector &names) { + if (input.inputs.size() != 2 || input.inputs[0].IsNull() || input.inputs[1].IsNull()) + throw BinderException("dynTimeWarpPath: expects two non-null temporal arguments"); + auto bind = make_uniq(); + bind->a = StringValue::Get(input.inputs[0]); + bind->b = StringValue::Get(input.inputs[1]); + return_types = {LogicalType::INTEGER, LogicalType::INTEGER}; + names = {"i", "j"}; + return std::move(bind); +} +static unique_ptr PathInit_temporal_dyntimewarp_path(ClientContext &, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); + auto &bind = input.bind_data->Cast(); + auto state = make_uniq(); + Temporal *t1 = BlobToTemporal(bind.a); + Temporal *t2 = BlobToTemporal(bind.b); + int count = 0; + Match *path = temporal_dyntimewarp_path(t1, t2, &count); + free(t1); free(t2); + if (path) { + state->col0.reserve(count); + state->col1.reserve(count); + for (int k = 0; k < count; k++) { + state->col0.push_back(path[k].i); + state->col1.push_back(path[k].j); + } + free(path); + } + return std::move(state); +} +static void PathExec_temporal_dyntimewarp_path(ClientContext &, TableFunctionInput &input, DataChunk &output) { + auto &state = input.global_state->Cast(); + idx_t total = state.col0.size(); + idx_t count = MinValue(STANDARD_VECTOR_SIZE, total - state.idx); + auto out0 = FlatVector::GetData(output.data[0]); + auto out1 = FlatVector::GetData(output.data[1]); + for (idx_t k = 0; k < count; k++) { + out0[k] = state.col0[state.idx + k]; + out1[k] = state.col1[state.idx + k]; + } + state.idx += count; + output.SetCardinality(count); +} + +static void Gen_temporal_frechet_distance(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = temporal_frechet_distance(t1, t2); + free(t1); free(t2); + return r; + }); +} + +struct PathBind_temporal_frechet_path : public TableFunctionData { string_t a, b; }; +struct PathState_temporal_frechet_path : public GlobalTableFunctionState { + idx_t idx = 0; + std::vector col0; + std::vector col1; +}; +static unique_ptr PathBindFn_temporal_frechet_path(ClientContext &, TableFunctionBindInput &input, + vector &return_types, vector &names) { + if (input.inputs.size() != 2 || input.inputs[0].IsNull() || input.inputs[1].IsNull()) + throw BinderException("frechetDistancePath: expects two non-null temporal arguments"); + auto bind = make_uniq(); + bind->a = StringValue::Get(input.inputs[0]); + bind->b = StringValue::Get(input.inputs[1]); + return_types = {LogicalType::INTEGER, LogicalType::INTEGER}; + names = {"i", "j"}; + return std::move(bind); +} +static unique_ptr PathInit_temporal_frechet_path(ClientContext &, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); + auto &bind = input.bind_data->Cast(); + auto state = make_uniq(); + Temporal *t1 = BlobToTemporal(bind.a); + Temporal *t2 = BlobToTemporal(bind.b); + int count = 0; + Match *path = temporal_frechet_path(t1, t2, &count); + free(t1); free(t2); + if (path) { + state->col0.reserve(count); + state->col1.reserve(count); + for (int k = 0; k < count; k++) { + state->col0.push_back(path[k].i); + state->col1.push_back(path[k].j); + } + free(path); + } + return std::move(state); +} +static void PathExec_temporal_frechet_path(ClientContext &, TableFunctionInput &input, DataChunk &output) { + auto &state = input.global_state->Cast(); + idx_t total = state.col0.size(); + idx_t count = MinValue(STANDARD_VECTOR_SIZE, total - state.idx); + auto out0 = FlatVector::GetData(output.data[0]); + auto out1 = FlatVector::GetData(output.data[1]); + for (idx_t k = 0; k < count; k++) { + out0[k] = state.col0[state.idx + k]; + out1[k] = state.col1[state.idx + k]; + } + state.idx += count; + output.SetCardinality(count); +} + +static void Gen_temporal_hausdorff_distance(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = temporal_hausdorff_distance(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_average_hausdorff_distance(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = temporal_average_hausdorff_distance(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_lcss_distance(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::Execute(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, double a2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = temporal_lcss_distance(t1, t2, a2); + free(t1); free(t2); + return r; + }); +} + + +// ===== @ingroup meos_temporal_analytics_simplify ===== +static void Gen_temporal_simplify_dp(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, double a2, bool a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_simplify_dp(t, a2, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_simplify_max_dist(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, double a2, bool a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_simplify_max_dist(t, a2, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_simplify_min_dist(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_simplify_min_dist(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_bbox_pos ===== +static void Gen_after_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = after_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_after_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = after_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_before_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = before_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_before_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = before_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_left_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = left_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overafter_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overafter_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overafter_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overafter_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overbefore_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overbefore_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overbefore_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overbefore_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overleft_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overleft_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overright_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overright_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_right_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = right_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_after_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = after_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_after_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = after_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_before_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = before_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_before_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = before_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_left_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = left_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_left_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = left_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overafter_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overafter_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overafter_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = overafter_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overbefore_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overbefore_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overbefore_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = overbefore_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overleft_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overleft_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overleft_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = overleft_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overright_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overright_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overright_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = overright_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_right_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = right_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_right_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = right_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_after_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = after_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_after_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = after_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_before_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = before_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_before_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = before_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_left_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = left_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_left_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = left_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overafter_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overafter_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overafter_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overafter_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overbefore_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overbefore_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overbefore_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overbefore_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overleft_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overleft_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overleft_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overleft_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overright_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overright_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overright_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overright_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_right_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = right_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_right_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = right_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + + +// ===== @ingroup meos_temporal_bbox_split ===== +static void Gen_temporal_spans(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Temporal *in = BlobToTemporal(blob); + int count = 0; + Span * arr = temporal_spans(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(Span)); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + +static void Gen_tnumber_tboxes(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto &in_vec = args.data[0]; + idx_t row_count = args.size(); + in_vec.Flatten(row_count); + auto &result_validity = FlatVector::Validity(result); + auto list_entries = FlatVector::GetData(result); + idx_t off = 0; + for (idx_t i = 0; i < row_count; ++i) { + if (in_vec.GetValue(i).IsNull()) { result_validity.SetInvalid(i); continue; } + string_t blob = FlatVector::GetData(in_vec)[i]; + Temporal *in = BlobToTemporal(blob); + int count = 0; + TBox * arr = tnumber_tboxes(in, &count); + free(in); + int n = (arr && count > 0) ? count : 0; + ListVector::Reserve(result, off + n); + ListVector::SetListSize(result, off + n); + list_entries[i] = list_entry_t{off, (uint64_t) n}; + if (n > 0) { + auto &child_vector = ListVector::GetEntry(result); + child_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto *cd = FlatVector::GetData(child_vector); + for (int j = 0; j < n; ++j) { cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(TBox)); } + off += n; + } + if (arr) free(arr); + result_validity.SetValid(i); + } +} + + +// ===== @ingroup meos_temporal_bbox_topo ===== +static void Gen_adjacent_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = adjacent_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_adjacent_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = adjacent_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contained_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contained_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contained_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contained_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contains_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contains_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_contains_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = contains_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overlaps_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overlaps_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_overlaps_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = overlaps_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_same_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = same_temporal_temporal(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_same_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = same_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_adjacent_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = adjacent_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_adjacent_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = adjacent_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_contained_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = contained_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_contained_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = contained_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_contains_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = contains_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_contains_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = contains_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_overlaps_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = overlaps_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_overlaps_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = overlaps_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_same_tbox_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + TBox *bx = BlobToTbox(a); + Temporal *t = BlobToTemporal(b); + bool r = same_tbox_tnumber(bx, t); + free(bx); free(t); + return r; + }); +} + +static void Gen_same_tnumber_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + TBox *bx = BlobToTbox(b); + bool r = same_tnumber_tbox(t, bx); + free(t); free(bx); + return r; + }); +} + +static void Gen_adjacent_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = adjacent_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_adjacent_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = adjacent_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_adjacent_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = adjacent_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_adjacent_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = adjacent_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_contained_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = contained_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_contained_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = contained_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_contained_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = contained_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_contained_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = contained_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_contains_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = contains_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_contains_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = contains_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_contains_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = contains_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_contains_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = contains_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overlaps_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overlaps_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_overlaps_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overlaps_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overlaps_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = overlaps_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_overlaps_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = overlaps_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_same_numspan_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = same_numspan_tnumber(cc, t); + free(cc); free(t); + return r; + }); +} + +static void Gen_same_temporal_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = same_temporal_tstzspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_same_tnumber_numspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + bool r = same_tnumber_numspan(t, cc); + free(t); free(cc); + return r; + }); +} + +static void Gen_same_tstzspan_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Span *cc = BlobToSpan(a); + Temporal *t = BlobToTemporal(b); + bool r = same_tstzspan_temporal(cc, t); + free(cc); free(t); + return r; + }); +} + + +// ===== @ingroup meos_temporal_bool ===== +static void Gen_tand_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tand_bool_tbool(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tand_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tand_tbool_bool(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tand_tbool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tand_tbool_tbool(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnot_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tnot_tbool(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tor_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tor_bool_tbool(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tor_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tor_tbool_bool(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tor_tbool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tor_tbool_tbool(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_comp_ever ===== +static void Gen_always_eq_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_bool_tbool(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_tbool_bool(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_eq_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_eq_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_eq_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_eq_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_eq_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_eq_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_ge_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_ge_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_ge_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ge_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ge_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_ge_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_gt_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_gt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_gt_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_gt_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_gt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_gt_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_always_le_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_le_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_le_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_le_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_le_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_le_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_le_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_le_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_lt_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_lt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_lt_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_lt_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_lt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_lt_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_bool_tbool(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_tbool_bool(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = always_ne_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_always_ne_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = always_ne_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = always_ne_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_always_ne_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = always_ne_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_bool_tbool(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_tbool_bool(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_eq_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_eq_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_eq_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_eq_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_eq_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_eq_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_ge_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_ge_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_ge_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ge_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ge_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_ge_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_gt_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_gt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_gt_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_gt_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_gt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_gt_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_le_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_le_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_le_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_le_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_le_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_le_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_lt_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_lt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_lt_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_lt_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_lt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_lt_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_bool_tbool(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_float_tfloat(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_int_tint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_tbool_bool(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = ever_ne_temporal_temporal(t1, t2); + free(t1); free(t2); + return (r != 0); + }); +} + +static void Gen_ever_ne_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + int32_t r = ever_ne_text_ttext(a1t, t); + free(a1t); free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_tfloat_float(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_tint_int(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_bigint_tbigint(a1, t); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = ever_ne_tbigint_bigint(t, a2); + free(t); + return (r != 0); + }); +} + +static void Gen_ever_ne_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2) { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + int32_t r = ever_ne_ttext_text(t, a2t); + free(a2t); free(t); + return (r != 0); + }); +} + + +// ===== @ingroup meos_temporal_comp_temp ===== +static void Gen_teq_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_bool_tbool(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_tbool_bool(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = teq_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = teq_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = teq_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_teq_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = teq_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tge_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tge_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tge_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = tge_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tge_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tge_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tge_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = tge_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgt_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgt_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tgt_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = tgt_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgt_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tgt_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tgt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = tgt_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tle_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tle_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tle_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = tle_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tle_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tle_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tle_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = tle_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tlt_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tlt_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tlt_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = tlt_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tlt_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tlt_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tlt_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = tlt_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_bool_tbool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](bool a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_bool_tbool(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_tbool_bool(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_tbool_bool(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_temporal_temporal(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tne_temporal_temporal(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = tne_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tne_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tne_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = tne_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_comp_trad ===== +static void Gen_temporal_cmp(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = temporal_cmp(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_eq(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_eq(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_ge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_ge(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_gt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_gt(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_le(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_le(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_lt(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_lt(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_temporal_ne(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + bool r = temporal_ne(t1, t2); + free(t1); free(t2); + return r; + }); +} + + +// ===== @ingroup meos_temporal_constructor ===== +static void Gen_tsequence_make(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto rc = args.size(); + auto &arr = args.data[0]; arr.Flatten(rc); + auto &child = ListVector::GetEntry(arr); + child.Flatten(ListVector::GetListSize(arr)); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; + bool lower_inc = true, upper_inc = true; + if (args.ColumnCount() > 1) { auto &c = args.data[1]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); } + if (args.ColumnCount() > 2) { auto &c = args.data[2]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) lower_inc = v.GetValue(); } + if (args.ColumnCount() > 3) { auto &c = args.data[3]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) upper_inc = v.GetValue(); } + UnaryExecutor::ExecuteWithNulls(arr, result, rc, + [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t { + int n = 0; + const Temporal **a = ListToTemporalArr(child, le, &n); + TSequence *seq = tsequence_make((TInstant **) a, n, lower_inc, upper_inc, interp, true); + string_t out = TemporalToBlobN(result, (Temporal *) seq, mask, idx); + FreeTemporalArr(a, n); + return out; + }); +} + +static void Gen_tsequenceset_make(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto rc = args.size(); + auto &arr = args.data[0]; arr.Flatten(rc); + auto &child = ListVector::GetEntry(arr); + child.Flatten(ListVector::GetListSize(arr)); + UnaryExecutor::ExecuteWithNulls(arr, result, rc, + [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t { + int n = 0; + const Temporal **a = ListToTemporalArr(child, le, &n); + TSequenceSet *ss = tsequenceset_make((TSequence **) a, n, true); + string_t out = TemporalToBlobN(result, (Temporal *) ss, mask, idx); + FreeTemporalArr(a, n); + return out; + }); +} + +static void Gen_tsequenceset_make_gaps(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + auto rc = args.size(); + auto &arr = args.data[0]; arr.Flatten(rc); + auto &child = ListVector::GetEntry(arr); + child.Flatten(ListVector::GetListSize(arr)); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; + MeosInterval maxt_val; bool has_maxt = false; double maxdist = -1.0; + if (args.ColumnCount() > 1) { auto &c = args.data[1]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) { maxt_val = IntervaltToInterval(v.GetValue()); has_maxt = true; } } + if (args.ColumnCount() > 2) { auto &c = args.data[2]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) maxdist = v.GetValue(); } + if (args.ColumnCount() > 3) { auto &c = args.data[3]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); } + const MeosInterval *maxt = has_maxt ? &maxt_val : NULL; + UnaryExecutor::ExecuteWithNulls(arr, result, rc, + [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t { + int n = 0; + const Temporal **a = ListToTemporalArr(child, le, &n); + TSequenceSet *ss = tsequenceset_make_gaps((TInstant **) a, n, interp, maxt, maxdist); + string_t out = TemporalToBlobN(result, (Temporal *) ss, mask, idx); + FreeTemporalArr(a, n); + return out; + }); +} + + +// ===== @ingroup meos_temporal_conversion ===== +static void Gen_tbool_to_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbool_to_tint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_to_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_to_tint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_to_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_to_tbigint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_to_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_to_tfloat(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_to_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_to_tbigint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbigint_to_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_to_tint(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbigint_to_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_to_tfloat(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_to_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Span *r = temporal_to_tstzspan(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_tnumber_to_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Span *r = tnumber_to_span(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return SpanToBlob(result, r); + }); +} + +static void Gen_tnumber_to_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + TBox *r = tnumber_to_tbox(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return TboxToBlob(result, r); + }); +} + + +// ===== @ingroup meos_temporal_dist ===== +static void Gen_tdistance_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tdistance_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdistance_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tdistance_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tdistance_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = tdistance_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_nad_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2) { + Temporal *t = BlobToTemporal(in); + double r = nad_tfloat_float(t, a2); + free(t); + return r; + }); +} + +static void Gen_nad_tfloat_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + double r = nad_tfloat_tfloat(t1, t2); + free(t1); free(t2); + return r; + }); +} + +static void Gen_nad_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2) { + Temporal *t = BlobToTemporal(in); + int32_t r = nad_tint_int(t, a2); + free(t); + return r; + }); +} + +static void Gen_nad_tint_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2) { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + int32_t r = nad_tint_tint(t1, t2); + free(t1); free(t2); + return r; + }); +} + + +// ===== @ingroup meos_temporal_inout ===== +static void Gen_temporal_as_hexwkb(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + if (args.ColumnCount() > 1) { + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t endian, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *x = BlobToTemporal(in); + uint8_t variant = wkb_variant_from_endian(endian.GetString().c_str()); + size_t sz = 0; + char *hex = temporal_as_hexwkb(x, variant, &sz); + free(x); + if (!hex) { mask.SetInvalid(idx); return string_t(); } + string_t out = StringVector::AddString(result, hex); + free(hex); + return out; + }); + } else { + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *x = BlobToTemporal(in); + size_t sz = 0; + char *hex = temporal_as_hexwkb(x, (uint8_t) 0, &sz); + free(x); + if (!hex) { mask.SetInvalid(idx); return string_t(); } + string_t out = StringVector::AddString(result, hex); + free(hex); + return out; + }); + } +} + +static void Gen_temporal_from_hexwkb(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *r = temporal_from_hexwkb(in.GetString().c_str()); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_math ===== +static void Gen_add_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_bigint_tbigint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = add_tbigint_bigint(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_add_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = add_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_div_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = div_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_div_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = div_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_div_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = div_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_div_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = div_bigint_tbigint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_div_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = div_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_bigint_tbigint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = mul_tbigint_bigint(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_mul_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = mul_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_float_tfloat(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](double a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_float_tfloat(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_int_tint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int32_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_int_tint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_tfloat_float(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_tfloat_float(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_tint_int(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_tint_int(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_bigint_tbigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](int64_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_bigint_tbigint(a1, t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_tbigint_bigint(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = sub_tbigint_bigint(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_sub_tnumber_tnumber(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = sub_tnumber_tnumber(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_derivative(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_derivative(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_exp(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_exp(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_ln(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_ln(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_log10(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_log10(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_sin(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_sin(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_cos(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_cos(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_tan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_tan(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_abs(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tnumber_abs(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_trend(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tnumber_trend(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_angular_difference(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tnumber_angular_difference(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_delta_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tnumber_delta_value(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_modif ===== +static void Gen_temporal_delete_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, timestamp_tz_t a2, bool a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_delete_timestamptz(t, DuckDBToMeosTimestamp(a2).value, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_insert(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = temporal_insert(t1, t2, a2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_merge(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = temporal_merge(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_update(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in1, string_t in2, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = temporal_update(t1, t2, a2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_restrict ===== +static void Gen_tbool_at_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbool_at_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbool_minus_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbool_minus_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_after_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, timestamp_tz_t a2, bool a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_after_timestamptz(t, DuckDBToMeosTimestamp(a2).value, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_at_max(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_at_max(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_at_min(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_at_min(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_at_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, timestamp_tz_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_at_timestamptz(t, DuckDBToMeosTimestamp(a2).value); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_before_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, timestamp_tz_t a2, bool a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_before_timestamptz(t, DuckDBToMeosTimestamp(a2).value, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_minus_max(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_minus_max(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_minus_min(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_minus_min(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_minus_timestamptz(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, timestamp_tz_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_minus_timestamptz(t, DuckDBToMeosTimestamp(a2).value); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_at_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_at_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_minus_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_minus_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_at_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_at_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_minus_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_minus_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttext_at_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = ttext_at_value(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttext_minus_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = ttext_minus_value(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_at_tstzset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Set *cc = BlobToSet(b); + Temporal *r = temporal_at_tstzset(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_at_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + Temporal *r = temporal_at_tstzspan(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_at_tstzspanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + SpanSet *cc = BlobToSpanSet(b); + Temporal *r = temporal_at_tstzspanset(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_minus_tstzset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Set *cc = BlobToSet(b); + Temporal *r = temporal_minus_tstzset(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_minus_tstzspan(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + Temporal *r = temporal_minus_tstzspan(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_minus_tstzspanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b) { + Temporal *t = BlobToTemporal(a); + SpanSet *cc = BlobToSpanSet(b); + Temporal *r = temporal_minus_tstzspanset(t, cc); + free(t); free(cc); + return TemporalToBlob(result, r); + }); +} + +static void Gen_temporal_at_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + Set *cc = BlobToSet(b); + Temporal *r = temporal_at_values(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_minus_values(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + Set *cc = BlobToSet(b); + Temporal *r = temporal_minus_values(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_at_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + Temporal *r = tnumber_at_span(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_at_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + SpanSet *cc = BlobToSpanSet(b); + Temporal *r = tnumber_at_spanset(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_at_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + TBox *cc = BlobToTbox(b); + Temporal *r = tnumber_at_tbox(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_minus_span(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + Span *cc = BlobToSpan(b); + Temporal *r = tnumber_minus_span(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_minus_spanset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + SpanSet *cc = BlobToSpanSet(b); + Temporal *r = tnumber_minus_spanset(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tnumber_minus_tbox(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(a); + TBox *cc = BlobToTbox(b); + Temporal *r = tnumber_minus_tbox(t, cc); + free(t); free(cc); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_spatial_rel_ever ===== +static void Gen_atouches_tpoint_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = atouches_tpoint_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + +static void Gen_etouches_tpoint_geo(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in_t, string_t in_g, ValidityMask &mask, idx_t idx) -> bool { + Temporal *t = BlobToTemporal(in_t); + GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t)); + if (MEOS_FLAGS_GET_GEODETIC(t->flags)) { + GSERIALIZED *gs_geog = geom_to_geog(gs); + free(gs); gs = gs_geog; + } + int r = etouches_tpoint_geo(t, gs); + free(t); free(gs); + if (r < 0) { mask.SetInvalid(idx); return false; } + return r != 0; + }); +} + + +// ===== @ingroup meos_temporal_text ===== +static void Gen_textcat_text_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a1t = MakeText(a1); + Temporal *r = textcat_text_ttext(a1t, t); + free(a1t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_textcat_ttext_text(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, string_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + text *a2t = MakeText(a2); + Temporal *r = textcat_ttext_text(t, a2t); + free(a2t); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_textcat_ttext_ttext(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t1 = BlobToTemporal(in1); + Temporal *t2 = BlobToTemporal(in2); + Temporal *r = textcat_ttext_ttext(t1, t2); + free(t1); free(t2); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttext_initcap(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = ttext_initcap(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttext_upper(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = ttext_upper(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_ttext_lower(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = ttext_lower(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_temporal_transf ===== +static void Gen_temporal_round(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_round(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_round_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = temporal_round(t, 0); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_to_tinstant(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_to_tinstant(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_to_tsequence(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + interpType interp = INTERP_NONE; + if (args.ColumnCount() > 1) { auto &c = args.data[1]; c.Flatten(args.size()); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); } + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_to_tsequence(t, interp); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_temporal_to_tsequenceset(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + interpType interp = INTERP_NONE; + if (args.ColumnCount() > 1) { auto &c = args.data[1]; c.Flatten(args.size()); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); } + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = (Temporal *) temporal_to_tsequenceset(t, interp); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_ceil(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_ceil(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_degrees(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, bool a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_degrees(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_degrees_d(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_degrees(t, false); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_floor(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_floor(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_radians(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(), + [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_radians(t); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_scale_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_shift_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, double a2, double a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_shift_scale_value(t, a2, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tfloat_shift_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, double a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tfloat_shift_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_scale_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbigint_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_scale_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_shift_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, int32_t a2, int32_t a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_shift_scale_value(t, a2, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbigint_shift_scale_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + TernaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], args.data[2], result, args.size(), + [&](string_t in, int64_t a2, int64_t a3, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_shift_scale_value(t, a2, a3); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tint_shift_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int32_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tint_shift_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tbigint_shift_value(DataChunk &args, ExpressionState &, Vector &result) { + EnsureMeosThreadInitialized(); + BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(), + [&](string_t in, int64_t a2, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemporal(in); + Temporal *r = tbigint_shift_value(t, a2); + free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +} // anonymous + +static void RegisterGenerated_meos_box_bbox_pos(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_after_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_before_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overafter_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overbefore_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tbox_tbox)); +} + +static void RegisterGenerated_meos_box_bbox_topo(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tbox_tbox)); +} + +static void RegisterGenerated_meos_box_comp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TboxType::tbox(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_tbox_ne)); +} + +static void RegisterGenerated_meos_box_set(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("intersection", {TboxType::tbox(), TboxType::tbox()}, TboxType::tbox(), Gen_intersection_tbox_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TboxType::tbox(), TboxType::tbox()}, TboxType::tbox(), Gen_intersection_tbox_tbox)); +} + +static void RegisterGenerated_meos_cbuffer_accessor(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {CbufferTypes::tcbuffer()}, CbufferTypes::cbuffer(), Gen_tcbuffer_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("convexHull", {CbufferTypes::tcbuffer()}, GeoTypes::GEOMETRY(), Gen_tcbuffer_convex_hull)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {CbufferTypes::tcbuffer()}, CbufferTypes::cbuffer(), Gen_tcbuffer_start_value)); +} + +static void RegisterGenerated_meos_cbuffer_comp_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_always_eq_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_always_eq_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_always_eq_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_always_eq_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_always_ne_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_always_ne_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_always_ne_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_always_ne_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_ever_eq_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_ever_eq_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ever_eq_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ever_eq_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_ever_ne_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_ever_ne_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ever_ne_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ever_ne_tcbuffer_tcbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_comp_temp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_teq_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_tne_tcbuffer_cbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_conversion(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloat", {CbufferTypes::tcbuffer()}, TemporalTypes::tfloat(), Gen_tcbuffer_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {CbufferTypes::tcbuffer()}, TemporalTypes::tfloat(), Gen_tcbuffer_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeompoint", {CbufferTypes::tcbuffer()}, TgeompointType::tgeompoint(), Gen_tcbuffer_to_tgeompoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {CbufferTypes::tcbuffer()}, TgeompointType::tgeompoint(), Gen_tcbuffer_to_tgeompoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tcbuffer", {TGeometryTypes::tgeometry()}, CbufferTypes::tcbuffer(), Gen_tgeometry_to_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeometryTypes::tgeometry()}, CbufferTypes::tcbuffer(), Gen_tgeometry_to_tcbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_dist(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tfloat(), Gen_tdistance_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::DOUBLE, Gen_nad_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::DOUBLE, Gen_nad_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachInstant", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, CbufferTypes::tcbuffer(), Gen_nai_tcbuffer_cbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_rel_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aCovers", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_acovers_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_adisjoint_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_adisjoint_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adisjoint_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_aintersects_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_aintersects_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_aintersects_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_atouches_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_atouches_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_econtains_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_econtains_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ecovers_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_ecovers_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ecovers_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_edisjoint_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_edisjoint_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_eintersects_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_eintersects_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_eintersects_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_etouches_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, LogicalType::BOOLEAN, Gen_etouches_tcbuffer_cbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_rel_temp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tcontains_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tcontains_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_tcontains_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tcontains_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tcovers_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tcovers_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_tcovers_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tcovers_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tdisjoint_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tdisjoint_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_tdisjoint_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tdisjoint_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tintersects_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tintersects_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_tintersects_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tintersects_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {GeoTypes::GEOMETRY(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_ttouches_geo_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_ttouches_tcbuffer_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, TemporalTypes::tbool(), Gen_ttouches_tcbuffer_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_ttouches_tcbuffer_tcbuffer)); +} + +static void RegisterGenerated_meos_cbuffer_restrict(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, CbufferTypes::tcbuffer(), Gen_tcbuffer_at_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atGeometry", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, CbufferTypes::tcbuffer(), Gen_tcbuffer_at_geom)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {CbufferTypes::tcbuffer(), CbufferTypes::cbuffer()}, CbufferTypes::tcbuffer(), Gen_tcbuffer_minus_cbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusGeometry", {CbufferTypes::tcbuffer(), GeoTypes::GEOMETRY()}, CbufferTypes::tcbuffer(), Gen_tcbuffer_minus_geom)); +} + +static void RegisterGenerated_meos_cbuffer_transf(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {CbufferTypes::tcbuffer(), LogicalType::DOUBLE}, CbufferTypes::tcbuffer(), Gen_tcbuffer_expand)); +} + +static void RegisterGenerated_meos_geo_accessor(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("angularDifference", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_angular_difference)); + RegisterSerializedScalarFunction(loader, ScalarFunction("angularDifference", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_angular_difference)); + RegisterSerializedScalarFunction(loader, ScalarFunction("azimuth", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_azimuth)); + RegisterSerializedScalarFunction(loader, ScalarFunction("azimuth", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_azimuth)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cumulativeLength", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_cumulative_length)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cumulativeLength", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_cumulative_length)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getX", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_x)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getX", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_x)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getY", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_y)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getY", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_y)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getZ", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_z)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getZ", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_get_z)); + RegisterSerializedScalarFunction(loader, ScalarFunction("isSimple", {TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_tpoint_is_simple)); + RegisterSerializedScalarFunction(loader, ScalarFunction("isSimple", {TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_tpoint_is_simple)); + RegisterSerializedScalarFunction(loader, ScalarFunction("length", {TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_tpoint_length)); + RegisterSerializedScalarFunction(loader, ScalarFunction("length", {TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_tpoint_length)); + RegisterSerializedScalarFunction(loader, ScalarFunction("speed", {TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tpoint_speed)); + RegisterSerializedScalarFunction(loader, ScalarFunction("speed", {TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tpoint_speed)); +} + +static void RegisterGenerated_meos_geo_bbox_pos(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_above_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_after_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_after_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_after_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_after_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_after_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_back_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_before_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_before_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_before_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_before_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_before_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_below_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("front", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_front_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overback_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overfront", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overfront_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overright_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_right_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_above_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_after_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_after_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_after_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_after_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_after_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_back_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_before_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_before_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_before_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_before_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_before_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_below_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("front", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_front_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overabove_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overabove", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|&>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overafter_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overafter_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overafter_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overafter_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overafter_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overback_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overfront", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overfront_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overright_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_right_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_tspatial_stbox)); +} + +static void RegisterGenerated_meos_geo_bbox_topo(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeompointType::tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeogpointType::tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeometryTypes::tgeometry(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeographyTypes::tgeography(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {CbufferTypes::tcbuffer(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); +} + +static void RegisterGenerated_meos_geo_box_comp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_stbox_ne)); +} + +static void RegisterGenerated_meos_geo_box_pos(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("above", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|>>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_above_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_after_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("back", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/>>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_back_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_before_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("below", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<|", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_below_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("front", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_front_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overabove_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overafter_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overback", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/&>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overback_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbefore_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbelow", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<|", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overbelow_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overfront", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overfront_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overright_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_right_stbox_stbox)); +} + +static void RegisterGenerated_meos_geo_box_set(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("stbox_intersection", {StboxType::stbox(), StboxType::stbox()}, StboxType::stbox(), Gen_intersection_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {StboxType::stbox(), StboxType::stbox()}, StboxType::stbox(), Gen_intersection_stbox_stbox)); +} + +static void RegisterGenerated_meos_geo_box_topo(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_stbox_stbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_stbox_stbox)); +} + +static void RegisterGenerated_meos_geo_comp_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_always_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_eq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_eq_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_ne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_ever_ne_tgeo_tgeo)); +} + +static void RegisterGenerated_meos_geo_comp_temp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_teq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_teq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_teq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_teq_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_teq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_teq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_teq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_teq_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_tne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_tne_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tne_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tne_tgeo_geo)); +} + +static void RegisterGenerated_meos_geo_conversion(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeometry", {TgeogpointType::tgeogpoint()}, TGeographyTypes::tgeography(), Gen_tgeogpoint_to_tgeography)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TgeogpointType::tgeogpoint()}, TGeographyTypes::tgeography(), Gen_tgeogpoint_to_tgeography)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeompoint", {TGeographyTypes::tgeography()}, TgeogpointType::tgeogpoint(), Gen_tgeography_to_tgeogpoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeographyTypes::tgeography()}, TgeogpointType::tgeogpoint(), Gen_tgeography_to_tgeogpoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeometry", {TGeographyTypes::tgeography()}, TGeometryTypes::tgeometry(), Gen_tgeography_to_tgeometry)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeographyTypes::tgeography()}, TGeometryTypes::tgeometry(), Gen_tgeography_to_tgeometry)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeography", {TGeometryTypes::tgeometry()}, TGeographyTypes::tgeography(), Gen_tgeometry_to_tgeography)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeometryTypes::tgeometry()}, TGeographyTypes::tgeography(), Gen_tgeometry_to_tgeography)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeompoint", {TGeometryTypes::tgeometry()}, TgeompointType::tgeompoint(), Gen_tgeometry_to_tgeompoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeometryTypes::tgeometry()}, TgeompointType::tgeompoint(), Gen_tgeometry_to_tgeompoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tgeometry", {TgeompointType::tgeompoint()}, TGeometryTypes::tgeometry(), Gen_tgeompoint_to_tgeometry)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TgeompointType::tgeompoint()}, TGeometryTypes::tgeometry(), Gen_tgeompoint_to_tgeometry)); +} + +static void RegisterGenerated_meos_geo_distance(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tfloat(), Gen_tdistance_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|=|", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|=|", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|=|", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|=|", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::DOUBLE, Gen_nad_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistance", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::DOUBLE, Gen_mindistance_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistance", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::DOUBLE, Gen_mindistance_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistance", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::DOUBLE, Gen_mindistance_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistance", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::DOUBLE, Gen_mindistance_tgeoarr_tgeoarr)); +} + +static void RegisterGenerated_meos_geo_inout(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKT", {CbufferTypes::tcbuffer()}, LogicalType::VARCHAR, Gen_tspatial_as_ewkt_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, LogicalType::VARCHAR, Gen_tspatial_as_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_tspatial_as_text_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_tspatial_as_text_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_tspatial_as_text_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_tspatial_as_text_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asText", {CbufferTypes::tcbuffer()}, LogicalType::VARCHAR, Gen_tspatial_as_text_d)); +} + +static void RegisterGenerated_meos_geo_rel_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aContains", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_acontains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aContains", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_acontains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aContains", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_acontains_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aCovers", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_acovers_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aCovers", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_acovers_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aCovers", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_acovers_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjoint", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithin", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_aintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_aintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_aintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_aintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersects", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_aintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_atouches_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_atouches_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_atouches_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_atouches_geo_tpoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_econtains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_econtains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_econtains_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eContains", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_econtains_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ecovers_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_ecovers_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_ecovers_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_edisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_edisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_edisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_edisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjoint", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_edisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithin", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_edwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_eintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {GeoTypes::GEOMETRY(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_eintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_eintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {GeoTypes::GEOMETRY(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_eintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TGeographyTypes::tgeography(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersects", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_eintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_etouches_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_etouches_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_etouches_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_etouches_geo_tpoint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithinPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithinPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithinPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDwithinPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithinPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithinPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithinPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDwithinPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersectsPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_eintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersectsPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_eintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersectsPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_eintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eIntersectsPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_eintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersectsPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_aintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersectsPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_aintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersectsPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_aintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aIntersectsPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_aintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouchesPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_etouches_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouchesPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_atouches_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjointPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjointPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjointPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eDisjointPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_edisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjointPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjointPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjointPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aDisjointPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})), Gen_adisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aCovers", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_acovers_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eCovers", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_ecovers_tcbuffer_tcbuffer)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_etouches_tcbuffer_tcbuffer)); +} + +static void RegisterGenerated_meos_geo_rel_temp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tcontains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tcontains_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tcontains_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tContains", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tcontains_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tcovers_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tcovers_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tCovers", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tcovers_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tdisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tdisjoint_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjoint", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_tdisjoint_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithin", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tdwithin_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tintersects_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersects", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_tintersects_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_ttouches_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {GeoTypes::GEOMETRY(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_ttouches_geo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_ttouches_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {TGeometryTypes::tgeometry(), GeoTypes::GEOMETRY()}, TemporalTypes::tbool(), Gen_ttouches_tgeo_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouches", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_ttouches_tgeo_tgeo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithinPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDwithinPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::DOUBLE}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdwithin_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersectsPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersectsPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersectsPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tIntersectsPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tintersects_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tTouchesPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_ttouches_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjointPairs", {LogicalType::LIST(TgeompointType::tgeompoint()), LogicalType::LIST(TgeompointType::tgeompoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjointPairs", {LogicalType::LIST(TgeogpointType::tgeogpoint()), LogicalType::LIST(TgeogpointType::tgeogpoint())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjointPairs", {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::LIST(TGeometryTypes::tgeometry())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdisjoint_tgeoarr_tgeoarr)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDisjointPairs", {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::LIST(TGeographyTypes::tgeography())}, LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}, {"periods", SpansetTypes::tstzspanset()}})), Gen_tdisjoint_tgeoarr_tgeoarr)); +} + +static void RegisterGenerated_meos_geo_restrict(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("atGeometry", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TgeompointType::tgeompoint(), Gen_tpoint_at_geom)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atGeometry", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TgeogpointType::tgeogpoint(), Gen_tpoint_at_geom)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TgeompointType::tgeompoint(), Gen_tpoint_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TgeogpointType::tgeogpoint(), Gen_tpoint_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusGeometry", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TgeompointType::tgeompoint(), Gen_tpoint_minus_geom)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusGeometry", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TgeogpointType::tgeogpoint(), Gen_tpoint_minus_geom)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, TgeompointType::tgeompoint(), Gen_tpoint_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TgeogpointType::tgeogpoint(), GeoTypes::GEOMETRY()}, TgeogpointType::tgeogpoint(), Gen_tpoint_minus_value)); +} + +static void RegisterGenerated_meos_geo_srid(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("SRID", {TgeompointType::tgeompoint()}, LogicalType::INTEGER, Gen_tspatial_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("SRID", {TgeogpointType::tgeogpoint()}, LogicalType::INTEGER, Gen_tspatial_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("SRID", {TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Gen_tspatial_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("SRID", {TGeographyTypes::tgeography()}, LogicalType::INTEGER, Gen_tspatial_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("SRID", {CbufferTypes::tcbuffer()}, LogicalType::INTEGER, Gen_tspatial_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setSRID", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, TgeompointType::tgeompoint(), Gen_tspatial_set_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setSRID", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, TgeogpointType::tgeogpoint(), Gen_tspatial_set_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setSRID", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, TGeometryTypes::tgeometry(), Gen_tspatial_set_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setSRID", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, TGeographyTypes::tgeography(), Gen_tspatial_set_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setSRID", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, CbufferTypes::tcbuffer(), Gen_tspatial_set_srid)); + RegisterSerializedScalarFunction(loader, ScalarFunction("transform", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, TgeompointType::tgeompoint(), Gen_tspatial_transform)); + RegisterSerializedScalarFunction(loader, ScalarFunction("transform", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, TgeogpointType::tgeogpoint(), Gen_tspatial_transform)); + RegisterSerializedScalarFunction(loader, ScalarFunction("transform", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, TGeometryTypes::tgeometry(), Gen_tspatial_transform)); + RegisterSerializedScalarFunction(loader, ScalarFunction("transform", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, TGeographyTypes::tgeography(), Gen_tspatial_transform)); + RegisterSerializedScalarFunction(loader, ScalarFunction("transform", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, CbufferTypes::tcbuffer(), Gen_tspatial_transform)); +} + +static void RegisterGenerated_meos_internal_temporal_inout(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolFromMFJSON", {LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_temporal_from_mfjson)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintFromMFJSON", {LogicalType::VARCHAR}, TemporalTypes::tint(), Gen_temporal_from_mfjson)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintFromMFJSON", {LogicalType::VARCHAR}, TemporalTypes::tbigint(), Gen_temporal_from_mfjson)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatFromMFJSON", {LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_temporal_from_mfjson)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextFromMFJSON", {LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_temporal_from_mfjson)); +} + +static void RegisterGenerated_meos_quadbin_conversion(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tquadbin", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_tbigint_to_tquadbin)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_tbigint_to_tquadbin)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigint", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_tquadbin_to_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_tquadbin_to_tbigint)); +} + +static void RegisterGenerated_meos_setspan_accessor(ExtensionLoader &loader) { + for (auto &type : SetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("hash", {type}, LogicalType::INTEGER, Gen_set_hash)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numValues", {type}, LogicalType::INTEGER, Gen_set_num_values)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::bigintset()}, LogicalType::BIGINT, Gen_bigintset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::bigintset()}, LogicalType::BIGINT, Gen_bigintset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::dateset()}, LogicalType::DATE, Gen_dateset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::dateset()}, LogicalType::DATE, Gen_dateset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::floatset()}, LogicalType::DOUBLE, Gen_floatset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::floatset()}, LogicalType::DOUBLE, Gen_floatset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::intset()}, LogicalType::INTEGER, Gen_intset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::intset()}, LogicalType::INTEGER, Gen_intset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::textset()}, LogicalType::VARCHAR, Gen_textset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::textset()}, LogicalType::VARCHAR, Gen_textset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {SetTypes::tstzset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzset_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {SetTypes::tstzset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzset_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::bigintset()}, LogicalType::LIST(LogicalType::BIGINT), Gen_bigintset_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::dateset()}, LogicalType::LIST(LogicalType::DATE), Gen_dateset_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::floatset()}, LogicalType::LIST(LogicalType::DOUBLE), Gen_floatset_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::intset()}, LogicalType::LIST(LogicalType::INTEGER), Gen_intset_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::textset()}, LogicalType::LIST(LogicalType::VARCHAR), Gen_textset_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {SetTypes::tstzset()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_tstzset_values)); + for (auto &type : SpanTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("span_hash", {type}, LogicalType::INTEGER, Gen_span_hash)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower_inc", {type}, LogicalType::BOOLEAN, Gen_span_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower_inc", {type}, LogicalType::BOOLEAN, Gen_span_upper_inc)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpanTypes::bigintspan()}, LogicalType::BIGINT, Gen_bigintspan_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpanTypes::bigintspan()}, LogicalType::BIGINT, Gen_bigintspan_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("width", {SpanTypes::bigintspan()}, LogicalType::BIGINT, Gen_bigintspan_width)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {SpanTypes::datespan()}, LogicalType::INTERVAL, Gen_datespan_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpanTypes::datespan()}, LogicalType::DATE, Gen_datespan_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpanTypes::datespan()}, LogicalType::DATE, Gen_datespan_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpanTypes::floatspan()}, LogicalType::DOUBLE, Gen_floatspan_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpanTypes::floatspan()}, LogicalType::DOUBLE, Gen_floatspan_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("width", {SpanTypes::floatspan()}, LogicalType::DOUBLE, Gen_floatspan_width)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpanTypes::intspan()}, LogicalType::INTEGER, Gen_intspan_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpanTypes::intspan()}, LogicalType::INTEGER, Gen_intspan_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("width", {SpanTypes::intspan()}, LogicalType::INTEGER, Gen_intspan_width)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {SpanTypes::tstzspan()}, LogicalType::INTERVAL, Gen_tstzspan_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpanTypes::tstzspan()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspan_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpanTypes::tstzspan()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspan_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpansetTypes::bigintspanset()}, LogicalType::BIGINT, Gen_bigintspanset_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpansetTypes::bigintspanset()}, LogicalType::BIGINT, Gen_bigintspanset_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {SpansetTypes::datespanset(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_datespanset_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endDate", {SpansetTypes::datespanset()}, LogicalType::DATE, Gen_datespanset_end_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numDates", {SpansetTypes::datespanset()}, LogicalType::INTEGER, Gen_datespanset_num_dates)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startDate", {SpansetTypes::datespanset()}, LogicalType::DATE, Gen_datespanset_start_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpansetTypes::floatspanset()}, LogicalType::DOUBLE, Gen_floatspanset_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpansetTypes::floatspanset()}, LogicalType::DOUBLE, Gen_floatspanset_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpansetTypes::intspanset()}, LogicalType::INTEGER, Gen_intspanset_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpansetTypes::intspanset()}, LogicalType::INTEGER, Gen_intspanset_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_tstzspanset_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {SpansetTypes::tstzspanset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspanset_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SpansetTypes::tstzspanset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspanset_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {SpansetTypes::tstzspanset()}, LogicalType::INTEGER, Gen_tstzspanset_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {SpansetTypes::tstzspanset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspanset_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SpansetTypes::tstzspanset()}, LogicalType::TIMESTAMP_TZ, Gen_tstzspanset_upper)); + for (auto &type : SpansetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("spanset_hash", {type}, LogicalType::INTEGER, Gen_spanset_hash)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower_inc", {type}, LogicalType::BOOLEAN, Gen_spanset_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSpans", {type}, LogicalType::INTEGER, Gen_spanset_num_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower_inc", {type}, LogicalType::BOOLEAN, Gen_spanset_upper_inc)); + } +} + +static void RegisterGenerated_meos_setspan_bbox_split(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SpansetTypes::intspanset()}, LogicalType::LIST(SpanTypes::intspan()), Gen_spanset_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SpansetTypes::bigintspanset()}, LogicalType::LIST(SpanTypes::bigintspan()), Gen_spanset_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SpansetTypes::floatspanset()}, LogicalType::LIST(SpanTypes::floatspan()), Gen_spanset_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SpansetTypes::datespanset()}, LogicalType::LIST(SpanTypes::datespan()), Gen_spanset_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SpansetTypes::tstzspanset()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_spanset_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SetTypes::intset()}, LogicalType::LIST(SpanTypes::intspan()), Gen_set_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SetTypes::bigintset()}, LogicalType::LIST(SpanTypes::bigintspan()), Gen_set_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SetTypes::floatset()}, LogicalType::LIST(SpanTypes::floatspan()), Gen_set_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SetTypes::dateset()}, LogicalType::LIST(SpanTypes::datespan()), Gen_set_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {SetTypes::tstzset()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_set_spans)); +} + +static void RegisterGenerated_meos_setspan_comp(ExtensionLoader &loader) { + for (auto &type : SetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {type, type}, LogicalType::BOOLEAN, Gen_set_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {type, type}, LogicalType::BOOLEAN, Gen_set_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {type, type}, LogicalType::BOOLEAN, Gen_set_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {type, type}, LogicalType::BOOLEAN, Gen_set_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {type, type}, LogicalType::BOOLEAN, Gen_set_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {type, type}, LogicalType::BOOLEAN, Gen_set_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {type, type}, LogicalType::BOOLEAN, Gen_set_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {type, type}, LogicalType::BOOLEAN, Gen_set_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {type, type}, LogicalType::BOOLEAN, Gen_set_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {type, type}, LogicalType::BOOLEAN, Gen_set_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {type, type}, LogicalType::BOOLEAN, Gen_set_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {type, type}, LogicalType::BOOLEAN, Gen_set_ne)); + } + for (auto &type : SpanTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {type, type}, LogicalType::BOOLEAN, Gen_span_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {type, type}, LogicalType::BOOLEAN, Gen_span_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {type, type}, LogicalType::BOOLEAN, Gen_span_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {type, type}, LogicalType::BOOLEAN, Gen_span_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {type, type}, LogicalType::BOOLEAN, Gen_span_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {type, type}, LogicalType::BOOLEAN, Gen_span_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {type, type}, LogicalType::BOOLEAN, Gen_span_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {type, type}, LogicalType::BOOLEAN, Gen_span_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {type, type}, LogicalType::BOOLEAN, Gen_span_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {type, type}, LogicalType::BOOLEAN, Gen_span_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {type, type}, LogicalType::BOOLEAN, Gen_span_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {type, type}, LogicalType::BOOLEAN, Gen_span_ne)); + } + for (auto &type : SpansetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {type, type}, LogicalType::BOOLEAN, Gen_spanset_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {type, type}, LogicalType::BOOLEAN, Gen_spanset_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {type, type}, LogicalType::BOOLEAN, Gen_spanset_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {type, type}, LogicalType::BOOLEAN, Gen_spanset_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {type, type}, LogicalType::BOOLEAN, Gen_spanset_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {type, type}, LogicalType::BOOLEAN, Gen_spanset_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {type, type}, LogicalType::BOOLEAN, Gen_spanset_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {type, type}, LogicalType::BOOLEAN, Gen_spanset_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {type, type}, LogicalType::BOOLEAN, Gen_spanset_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {type, type}, LogicalType::BOOLEAN, Gen_spanset_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {type, type}, LogicalType::BOOLEAN, Gen_spanset_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {type, type}, LogicalType::BOOLEAN, Gen_spanset_ne)); + } +} + +static void RegisterGenerated_meos_setspan_conversion(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzset", {SetTypes::dateset()}, SetTypes::tstzset(), Gen_dateset_to_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SetTypes::dateset()}, SetTypes::tstzset(), Gen_dateset_to_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("intset", {SetTypes::floatset()}, SetTypes::intset(), Gen_floatset_to_intset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SetTypes::floatset()}, SetTypes::intset(), Gen_floatset_to_intset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatset", {SetTypes::intset()}, SetTypes::floatset(), Gen_intset_to_floatset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SetTypes::intset()}, SetTypes::floatset(), Gen_intset_to_floatset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("dateset", {SetTypes::tstzset()}, SetTypes::dateset(), Gen_tstzset_to_dateset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SetTypes::tstzset()}, SetTypes::dateset(), Gen_tstzset_to_dateset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzspan", {SpanTypes::datespan()}, SpanTypes::tstzspan(), Gen_datespan_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpanTypes::datespan()}, SpanTypes::tstzspan(), Gen_datespan_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("intspan", {SpanTypes::floatspan()}, SpanTypes::intspan(), Gen_floatspan_to_intspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpanTypes::floatspan()}, SpanTypes::intspan(), Gen_floatspan_to_intspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatspan", {SpanTypes::intspan()}, SpanTypes::floatspan(), Gen_intspan_to_floatspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpanTypes::intspan()}, SpanTypes::floatspan(), Gen_intspan_to_floatspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("datespan", {SpanTypes::tstzspan()}, SpanTypes::datespan(), Gen_tstzspan_to_datespan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpanTypes::tstzspan()}, SpanTypes::datespan(), Gen_tstzspan_to_datespan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzspanset", {SpansetTypes::datespanset()}, SpansetTypes::tstzspanset(), Gen_datespanset_to_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpansetTypes::datespanset()}, SpansetTypes::tstzspanset(), Gen_datespanset_to_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("intspanset", {SpansetTypes::floatspanset()}, SpansetTypes::intspanset(), Gen_floatspanset_to_intspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpansetTypes::floatspanset()}, SpansetTypes::intspanset(), Gen_floatspanset_to_intspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatspanset", {SpansetTypes::intspanset()}, SpansetTypes::floatspanset(), Gen_intspanset_to_floatspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpansetTypes::intspanset()}, SpansetTypes::floatspanset(), Gen_intspanset_to_floatspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("datespanset", {SpansetTypes::tstzspanset()}, SpansetTypes::datespanset(), Gen_tstzspanset_to_datespanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {SpansetTypes::tstzspanset()}, SpansetTypes::datespanset(), Gen_tstzspanset_to_datespanset)); +} + +static void RegisterGenerated_meos_setspan_inout(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("intsetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::intset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("bigintsetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::bigintset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatsetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::floatset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("textsetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::textset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("datesetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::dateset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzsetFromHexWKB", {LogicalType::VARCHAR}, SetTypes::tstzset(), Gen_set_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("intspanFromHexWKB", {LogicalType::VARCHAR}, SpanTypes::intspan(), Gen_span_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("bigintspanFromHexWKB", {LogicalType::VARCHAR}, SpanTypes::bigintspan(), Gen_span_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatspanFromHexWKB", {LogicalType::VARCHAR}, SpanTypes::floatspan(), Gen_span_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzspanFromHexWKB", {LogicalType::VARCHAR}, SpanTypes::tstzspan(), Gen_span_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("datespanFromHexWKB", {LogicalType::VARCHAR}, SpanTypes::datespan(), Gen_span_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("intspansetFromHexWKB", {LogicalType::VARCHAR}, SpansetTypes::intspanset(), Gen_spanset_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("bigintspansetFromHexWKB", {LogicalType::VARCHAR}, SpansetTypes::bigintspanset(), Gen_spanset_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floatspansetFromHexWKB", {LogicalType::VARCHAR}, SpansetTypes::floatspanset(), Gen_spanset_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("datespansetFromHexWKB", {LogicalType::VARCHAR}, SpansetTypes::datespanset(), Gen_spanset_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tstzspansetFromHexWKB", {LogicalType::VARCHAR}, SpansetTypes::tstzspanset(), Gen_spanset_from_hexwkb)); +} + +static void RegisterGenerated_meos_setspan_pos(ExtensionLoader &loader) { + for (auto &type : SetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {type, type}, LogicalType::BOOLEAN, Gen_left_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {type, type}, LogicalType::BOOLEAN, Gen_left_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {type, type}, LogicalType::BOOLEAN, Gen_overleft_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {type, type}, LogicalType::BOOLEAN, Gen_overleft_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {type, type}, LogicalType::BOOLEAN, Gen_overright_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {type, type}, LogicalType::BOOLEAN, Gen_overright_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {type, type}, LogicalType::BOOLEAN, Gen_right_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {type, type}, LogicalType::BOOLEAN, Gen_right_set_set)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_after_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_after_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_after_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_after_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_before_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_before_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_before_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_before_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_left_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_left_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_left_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_left_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_left_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_left_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_left_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_left_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_left_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_left_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_overafter_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overafter_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overafter_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_overafter_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_overbefore_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overbefore_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overbefore_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_overbefore_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_overleft_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_overleft_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_overleft_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_overleft_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_overleft_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_overleft_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_overleft_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_overleft_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_overleft_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_overleft_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_overright_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_overright_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_overright_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_overright_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_overright_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_overright_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_right_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_right_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_right_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_right_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_right_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_right_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_right_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_right_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_right_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_right_text_set)); + for (auto &type : SpanTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {type, type}, LogicalType::BOOLEAN, Gen_left_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {type, type}, LogicalType::BOOLEAN, Gen_left_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {type, type}, LogicalType::BOOLEAN, Gen_overleft_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {type, type}, LogicalType::BOOLEAN, Gen_overleft_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {type, type}, LogicalType::BOOLEAN, Gen_overright_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {type, type}, LogicalType::BOOLEAN, Gen_overright_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {type, type}, LogicalType::BOOLEAN, Gen_right_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {type, type}, LogicalType::BOOLEAN, Gen_right_span_span)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_after_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_after_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_after_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_before_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_before_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_before_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_left_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_left_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_left_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_overafter_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overafter_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overafter_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_overbefore_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overbefore_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overbefore_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overleft_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overleft_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overleft_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overright_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overright_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overright_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_right_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_right_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_right_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_after_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_after_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_after_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_after_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_before_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_before_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_before_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_before_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_left_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_left_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_left_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_left_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_left_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_left_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_left_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_left_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_left_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_overafter_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overafter_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overafter_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_overafter_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_overbefore_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_overbefore_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_overbefore_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_overbefore_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overleft_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overleft_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overleft_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overleft_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overleft_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overleft_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overleft_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overleft_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overleft_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overright_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overright_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overright_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overright_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overright_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overright_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_overright_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_overright_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_overright_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_right_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_right_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_right_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_right_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_right_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_right_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_right_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_right_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_right_spanset_int)); + for (auto &type : SpansetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {type, type}, LogicalType::BOOLEAN, Gen_left_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {type, type}, LogicalType::BOOLEAN, Gen_left_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {type, type}, LogicalType::BOOLEAN, Gen_overleft_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {type, type}, LogicalType::BOOLEAN, Gen_overleft_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {type, type}, LogicalType::BOOLEAN, Gen_overright_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {type, type}, LogicalType::BOOLEAN, Gen_overright_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {type, type}, LogicalType::BOOLEAN, Gen_right_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {type, type}, LogicalType::BOOLEAN, Gen_right_spanset_spanset)); + } +} + +static void RegisterGenerated_meos_setspan_set(ExtensionLoader &loader) { + for (auto &type : SetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {type, type}, type, Gen_intersection_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {type, type}, type, Gen_intersection_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {type, type}, type, Gen_minus_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {type, type}, type, Gen_minus_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {type, type}, type, Gen_union_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {type, type}, type, Gen_union_set_set)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_intersection_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_intersection_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_intersection_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_intersection_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_intersection_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_intersection_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_intersection_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_intersection_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_intersection_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_intersection_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setIntersection", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_intersection_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_intersection_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_minus_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_minus_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_minus_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_minus_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_minus_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_minus_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_minus_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_minus_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_minus_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_minus_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setMinus", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_minus_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_minus_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_union_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::bigintset(), LogicalType::BIGINT}, SetTypes::bigintset(), Gen_union_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_union_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::dateset(), LogicalType::DATE}, SetTypes::dateset(), Gen_union_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_union_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::floatset(), LogicalType::DOUBLE}, SetTypes::floatset(), Gen_union_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_union_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), Gen_union_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_union_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_union_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("setUnion", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_union_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, SetTypes::tstzset(), Gen_union_set_timestamptz)); + for (auto &type : SpanTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("spanIntersection", {type, type}, type, Gen_intersection_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {type, type}, type, Gen_intersection_span_span)); + } + for (auto &type : SpansetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("spansetIntersection", {type, type}, type, Gen_intersection_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {type, type}, type, Gen_intersection_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spansetMinus", {type, type}, type, Gen_minus_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {type, type}, type, Gen_minus_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spansetUnion", {type, type}, type, Gen_union_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {type, type}, type, Gen_union_spanset_spanset)); + } +} + +static void RegisterGenerated_meos_setspan_topo(ExtensionLoader &loader) { + for (auto &type : SetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {type, type}, LogicalType::BOOLEAN, Gen_contained_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {type, type}, LogicalType::BOOLEAN, Gen_contained_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {type, type}, LogicalType::BOOLEAN, Gen_contains_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {type, type}, LogicalType::BOOLEAN, Gen_contains_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_set_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_set_set)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_contained_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, Gen_contained_bigint_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_contained_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, Gen_contained_date_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_contained_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, Gen_contained_float_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_contained_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, Gen_contained_int_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_contained_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, Gen_contained_text_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_set)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_set_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_set_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_set_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_set_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_contains_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_contains_set_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_set_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_set_timestamptz)); + for (auto &type : SpanTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {type, type}, LogicalType::BOOLEAN, Gen_adjacent_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {type, type}, LogicalType::BOOLEAN, Gen_adjacent_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {type, type}, LogicalType::BOOLEAN, Gen_contained_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {type, type}, LogicalType::BOOLEAN, Gen_contained_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {type, type}, LogicalType::BOOLEAN, Gen_contains_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {type, type}, LogicalType::BOOLEAN, Gen_contains_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_span_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_span_span)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_adjacent_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_adjacent_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_adjacent_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_adjacent_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adjacent_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adjacent_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_adjacent_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_adjacent_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_adjacent_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_adjacent_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_adjacent_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_adjacent_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_adjacent_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_adjacent_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_adjacent_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contained_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contained_bigint_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contained_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contained_date_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_float_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_int_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contained_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_span_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_span_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_span_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_span_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contains_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_span_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::intspan(), SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::datespan(), SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_overlaps_span_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpansetTypes::intspanset(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpansetTypes::datespanset(), SpanTypes::datespan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_spanset_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_adjacent_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_adjacent_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_adjacent_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_adjacent_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adjacent_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_adjacent_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_adjacent_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_adjacent_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_adjacent_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_adjacent_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contained_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::BIGINT, SpansetTypes::bigintspanset()}, LogicalType::BOOLEAN, Gen_contained_bigint_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contained_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DATE, SpansetTypes::datespanset()}, LogicalType::BOOLEAN, Gen_contained_date_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contained_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DOUBLE, SpansetTypes::floatspanset()}, LogicalType::BOOLEAN, Gen_contained_float_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contained_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::INTEGER, SpansetTypes::intspanset()}, LogicalType::BOOLEAN, Gen_contained_int_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::TIMESTAMP_TZ, SpansetTypes::tstzspanset()}, LogicalType::BOOLEAN, Gen_contained_timestamptz_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::bigintspanset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_contains_spanset_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::datespanset(), LogicalType::DATE}, LogicalType::BOOLEAN, Gen_contains_spanset_date)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::floatspanset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_contains_spanset_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::intspanset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_contains_spanset_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_spanset_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpansetTypes::tstzspanset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, Gen_contains_spanset_timestamptz)); + for (auto &type : SpansetTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {type, type}, LogicalType::BOOLEAN, Gen_adjacent_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {type, type}, LogicalType::BOOLEAN, Gen_adjacent_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {type, type}, LogicalType::BOOLEAN, Gen_contained_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {type, type}, LogicalType::BOOLEAN, Gen_contained_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {type, type}, LogicalType::BOOLEAN, Gen_contains_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {type, type}, LogicalType::BOOLEAN, Gen_contains_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_spanset_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {type, type}, LogicalType::BOOLEAN, Gen_overlaps_spanset_spanset)); + } +} + +static void RegisterGenerated_meos_setspan_transf(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("ceil", {SetTypes::floatset()}, SetTypes::floatset(), Gen_floatset_ceil)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SetTypes::floatset(), LogicalType::BOOLEAN}, SetTypes::floatset(), Gen_floatset_degrees)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SetTypes::floatset()}, SetTypes::floatset(), Gen_floatset_degrees_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floor", {SetTypes::floatset()}, SetTypes::floatset(), Gen_floatset_floor)); + RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {SetTypes::floatset()}, SetTypes::floatset(), Gen_floatset_radians)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SetTypes::floatset(), LogicalType::INTEGER}, SetTypes::floatset(), Gen_set_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SetTypes::floatset()}, SetTypes::floatset(), Gen_set_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("textset_cat", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_textcat_textset_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("||", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), Gen_textcat_textset_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("initcap", {SetTypes::textset()}, SetTypes::textset(), Gen_textset_initcap)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SetTypes::textset()}, SetTypes::textset(), Gen_textset_lower)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {SetTypes::textset()}, SetTypes::textset(), Gen_textset_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpanTypes::bigintspan(), Gen_bigintspan_expand)); + RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpanTypes::floatspan(), Gen_floatspan_expand)); + RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {SpanTypes::intspan(), LogicalType::INTEGER}, SpanTypes::intspan(), Gen_intspan_expand)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ceil", {SpanTypes::floatspan()}, SpanTypes::floatspan(), Gen_floatspan_ceil)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SpanTypes::floatspan(), LogicalType::BOOLEAN}, SpanTypes::floatspan(), Gen_floatspan_degrees)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SpanTypes::floatspan()}, SpanTypes::floatspan(), Gen_floatspan_degrees_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floor", {SpanTypes::floatspan()}, SpanTypes::floatspan(), Gen_floatspan_floor)); + RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {SpanTypes::floatspan()}, SpanTypes::floatspan(), Gen_floatspan_radians)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SpanTypes::floatspan(), LogicalType::INTEGER}, SpanTypes::floatspan(), Gen_floatspan_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SpanTypes::floatspan()}, SpanTypes::floatspan(), Gen_floatspan_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ceil", {SpansetTypes::floatspanset()}, SpansetTypes::floatspanset(), Gen_floatspanset_ceil)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floor", {SpansetTypes::floatspanset()}, SpansetTypes::floatspanset(), Gen_floatspanset_floor)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SpansetTypes::floatspanset(), LogicalType::BOOLEAN}, SpansetTypes::floatspanset(), Gen_floatspanset_degrees)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {SpansetTypes::floatspanset()}, SpansetTypes::floatspanset(), Gen_floatspanset_degrees_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {SpansetTypes::floatspanset()}, SpansetTypes::floatspanset(), Gen_floatspanset_radians)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SpansetTypes::floatspanset(), LogicalType::INTEGER}, SpansetTypes::floatspanset(), Gen_floatspanset_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {SpansetTypes::floatspanset()}, SpansetTypes::floatspanset(), Gen_floatspanset_round_d)); +} + +static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { + for (auto &type : TemporalTypes::AllTypes()) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tint_hash", {type}, LogicalType::INTEGER, Gen_temporal_hash)); + } + for (auto &type : std::vector{TgeompointType::tgeompoint(), TgeogpointType::tgeogpoint(), TGeometryTypes::tgeometry(), TGeographyTypes::tgeography(), CbufferTypes::tcbuffer()}) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tint_hash", {type}, LogicalType::INTEGER, Gen_temporal_hash)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_tbool_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_tbool_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbigint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tfloat(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::ttext(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TgeompointType::tgeompoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TgeogpointType::tgeogpoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TGeometryTypes::tgeometry(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TGeographyTypes::tgeography(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {CbufferTypes::tcbuffer(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tint()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbigint()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tbool()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::tfloat()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TemporalTypes::ttext()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TgeompointType::tgeompoint()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TgeogpointType::tgeogpoint()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TGeometryTypes::tgeometry()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TGeographyTypes::tgeography()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {CbufferTypes::tcbuffer()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tbigint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tbool()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::tfloat()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TemporalTypes::ttext()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TgeompointType::tgeompoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TgeogpointType::tgeogpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TGeometryTypes::tgeometry()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TGeographyTypes::tgeography()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {CbufferTypes::tcbuffer()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tbigint(), LogicalType::INTEGER}, TemporalTypes::tbigint(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tbool(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::tfloat(), LogicalType::INTEGER}, TemporalTypes::tfloat(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TemporalTypes::ttext(), LogicalType::INTEGER}, TemporalTypes::ttext(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, TgeompointType::tgeompoint(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, TgeogpointType::tgeogpoint(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, TGeometryTypes::tgeometry(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, TGeographyTypes::tgeography(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, CbufferTypes::tcbuffer(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::tfloat()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {CbufferTypes::tcbuffer()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_max_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_max_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_max_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxInstant", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_max_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_min_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_min_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minInstant", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_min_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minInstant", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_min_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TemporalTypes::tfloat()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TemporalTypes::ttext()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TgeompointType::tgeompoint()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TgeogpointType::tgeogpoint()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TGeographyTypes::tgeography()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {CbufferTypes::tcbuffer()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::tfloat()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TemporalTypes::ttext()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TgeompointType::tgeompoint()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TgeogpointType::tgeogpoint()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TGeographyTypes::tgeography()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {CbufferTypes::tcbuffer()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::tfloat()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TemporalTypes::ttext()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TgeompointType::tgeompoint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TgeogpointType::tgeogpoint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TGeographyTypes::tgeography()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {CbufferTypes::tcbuffer()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tbigint(), LogicalType::INTEGER}, TemporalTypes::tbigint(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tbool(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::tfloat(), LogicalType::INTEGER}, TemporalTypes::tfloat(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TemporalTypes::ttext(), LogicalType::INTEGER}, TemporalTypes::ttext(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, TgeompointType::tgeompoint(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, TgeogpointType::tgeogpoint(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, TGeometryTypes::tgeometry(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, TGeographyTypes::tgeography(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, CbufferTypes::tcbuffer(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tbigint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tbool()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::tfloat()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TemporalTypes::ttext()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TgeompointType::tgeompoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TgeogpointType::tgeogpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TGeometryTypes::tgeometry()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TGeographyTypes::tgeography()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {CbufferTypes::tcbuffer()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::tfloat()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {CbufferTypes::tcbuffer()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::tfloat()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {CbufferTypes::tcbuffer()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_min_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_max_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tfloat_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_tint_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::tbigint()}, LogicalType::BIGINT, Gen_tbigint_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxValue", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_tint_max_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxValue", {TemporalTypes::tbigint()}, LogicalType::BIGINT, Gen_tbigint_max_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minValue", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_tint_min_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minValue", {TemporalTypes::tbigint()}, LogicalType::BIGINT, Gen_tbigint_min_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TemporalTypes::tint()}, LogicalType::INTEGER, Gen_tint_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TemporalTypes::tbigint()}, LogicalType::BIGINT, Gen_tbigint_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("integral", {TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_tnumber_integral)); + RegisterSerializedScalarFunction(loader, ScalarFunction("integral", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tnumber_integral)); + RegisterSerializedScalarFunction(loader, ScalarFunction("twAvg", {TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_tnumber_twavg)); + RegisterSerializedScalarFunction(loader, ScalarFunction("twAvg", {TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_tnumber_twavg)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_ttext_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxValue", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_ttext_max_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minValue", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_ttext_min_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_ttext_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("getValues", {TemporalTypes::tbool()}, LogicalType::LIST(LogicalType::BOOLEAN), Gen_tbool_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {CbufferTypes::tcbuffer()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TGeometryTypes::tgeometry()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TGeographyTypes::tgeography()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TgeompointType::tgeompoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TgeogpointType::tgeogpoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tbool()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tbigint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::tfloat()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TemporalTypes::ttext()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); +} + +static void RegisterGenerated_meos_temporal_analytics_similarity(ExtensionLoader &loader) { + for (auto &type : TemporalTypes::AllTypes()) { + loader.RegisterFunction(TableFunction("dynTimeWarpPath", {type, type}, PathExec_temporal_dyntimewarp_path, PathBindFn_temporal_dyntimewarp_path, PathInit_temporal_dyntimewarp_path)); + loader.RegisterFunction(TableFunction("frechetDistancePath", {type, type}, PathExec_temporal_frechet_path, PathBindFn_temporal_frechet_path, PathInit_temporal_frechet_path)); + } + for (auto &type : std::vector{TgeompointType::tgeompoint(), TgeogpointType::tgeogpoint(), TGeometryTypes::tgeometry(), TGeographyTypes::tgeography(), CbufferTypes::tcbuffer()}) { + loader.RegisterFunction(TableFunction("dynTimeWarpPath", {type, type}, PathExec_temporal_dyntimewarp_path, PathBindFn_temporal_dyntimewarp_path, PathInit_temporal_dyntimewarp_path)); + loader.RegisterFunction(TableFunction("frechetDistancePath", {type, type}, PathExec_temporal_frechet_path, PathBindFn_temporal_frechet_path, PathInit_temporal_frechet_path)); + } + RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_temporal_dyntimewarp_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::DOUBLE, Gen_temporal_dyntimewarp_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_temporal_dyntimewarp_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_temporal_dyntimewarp_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_temporal_dyntimewarp_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_temporal_frechet_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::DOUBLE, Gen_temporal_frechet_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_temporal_frechet_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_temporal_frechet_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_temporal_frechet_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_temporal_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::DOUBLE, Gen_temporal_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_temporal_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_temporal_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_temporal_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("averageHausdorffDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::DOUBLE, Gen_temporal_average_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("averageHausdorffDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_temporal_average_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("averageHausdorffDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::DOUBLE, Gen_temporal_average_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("averageHausdorffDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::DOUBLE, Gen_temporal_average_hausdorff_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lcssDistance", {TemporalTypes::tint(), TemporalTypes::tint(), LogicalType::DOUBLE}, LogicalType::DOUBLE, Gen_temporal_lcss_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lcssDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, Gen_temporal_lcss_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lcssDistance", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint(), LogicalType::DOUBLE}, LogicalType::DOUBLE, Gen_temporal_lcss_distance)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lcssDistance", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint(), LogicalType::DOUBLE}, LogicalType::DOUBLE, Gen_temporal_lcss_distance)); +} + +static void RegisterGenerated_meos_temporal_analytics_simplify(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("douglasPeuckerSimplify", {TemporalTypes::tfloat(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_simplify_dp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("douglasPeuckerSimplify", {TgeompointType::tgeompoint(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_simplify_dp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("douglasPeuckerSimplify", {TGeometryTypes::tgeometry(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_simplify_dp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxDistSimplify", {TemporalTypes::tfloat(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_simplify_max_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxDistSimplify", {TgeompointType::tgeompoint(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_simplify_max_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("maxDistSimplify", {TGeometryTypes::tgeometry(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_simplify_max_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistSimplify", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_temporal_simplify_min_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistSimplify", {TgeompointType::tgeompoint(), LogicalType::DOUBLE}, TgeompointType::tgeompoint(), Gen_temporal_simplify_min_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistSimplify", {TgeogpointType::tgeogpoint(), LogicalType::DOUBLE}, TgeogpointType::tgeogpoint(), Gen_temporal_simplify_min_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistSimplify", {TGeometryTypes::tgeometry(), LogicalType::DOUBLE}, TGeometryTypes::tgeometry(), Gen_temporal_simplify_min_dist)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minDistSimplify", {TGeographyTypes::tgeography(), LogicalType::DOUBLE}, TGeographyTypes::tgeography(), Gen_temporal_simplify_min_dist)); +} + +static void RegisterGenerated_meos_temporal_bbox_pos(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_after_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_after_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_after_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_after_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_before_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_before_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_before_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_before_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overafter_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overafter_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overafter_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overafter_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overbefore_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overbefore_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_after_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_after_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_after_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_after_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_before_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_before_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_before_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_before_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_left_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overafter_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overafter_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overafter_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overafter_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overbefore_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overbefore_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overbefore_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overbefore_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overright_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_right_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_after_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_after_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_before_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_before_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_left_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_left_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_left_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("left", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_left_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overafter_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overafter_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overbefore_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overbefore_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overleft_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overleft_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overleft", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overleft_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overright_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overright_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overright_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overright", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overright_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_right_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_right_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_right_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("right", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_right_tnumber_numspan)); +} + +static void RegisterGenerated_meos_temporal_bbox_split(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TGeometryTypes::tgeometry()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TGeographyTypes::tgeography()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TgeompointType::tgeompoint()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TgeogpointType::tgeogpoint()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TemporalTypes::tbool()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TemporalTypes::tint()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TemporalTypes::tbigint()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TemporalTypes::tfloat()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("spans", {TemporalTypes::ttext()}, LogicalType::LIST(SpanTypes::tstzspan()), Gen_temporal_spans)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboxes", {TemporalTypes::tint()}, LogicalType::LIST(TboxType::tbox()), Gen_tnumber_tboxes)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboxes", {TemporalTypes::tfloat()}, LogicalType::LIST(TboxType::tbox()), Gen_tnumber_tboxes)); +} + +static void RegisterGenerated_meos_temporal_bbox_topo(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contained_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contained_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contained_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contained_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contains_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contains_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contains_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contains_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_same_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_same_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_same_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_same_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_same_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contained_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_contains_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TboxType::tbox(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TboxType::tbox(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tbox_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tint(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tfloat(), TboxType::tbox()}, LogicalType::BOOLEAN, Gen_same_tnumber_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_adjacent_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contained_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contained_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contains_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_contains_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contains_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_contains_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_overlaps_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::intspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::floatspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_numspan_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_same_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tint(), SpanTypes::intspan()}, LogicalType::BOOLEAN, Gen_same_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_same_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, LogicalType::BOOLEAN, Gen_same_tnumber_numspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); +} + +static void RegisterGenerated_meos_temporal_bool(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_and", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tand_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tand_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_and", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tand_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tand_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_and", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tand_tbool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tand_tbool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_not", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tnot_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("~", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tnot_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_or", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tor_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tor_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_or", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tor_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tor_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_or", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tor_tbool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tor_tbool_tbool)); +} + +static void RegisterGenerated_meos_temporal_comp_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_eq_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_eq_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_eq_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_eq_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_eq_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_eq_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_always_eq_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_always_eq_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_eq_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_eq_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_eq_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_eq_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_eq_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_eq_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_eq_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_eq_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_eq_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_eq_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aEq", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_eq_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_eq_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ge_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ge_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ge_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ge_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ge_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ge_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_ge_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_ge_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_ge_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_ge_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ge_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ge_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_ge_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_ge_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_ge_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_ge_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_gt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_gt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_gt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_gt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_gt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_gt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_gt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_gt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_gt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_gt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_gt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_gt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_gt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_gt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aGt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_gt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%>", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_gt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_le_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_le_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_le_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_le_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_le_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_le_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_le_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_le_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_le_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_le_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_le_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_le_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_le_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_le_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_le_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_le_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_lt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_lt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_lt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_lt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_lt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_lt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_lt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_lt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_lt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_lt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_lt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_lt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_lt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_lt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aLt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_lt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_lt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_ne_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_ne_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ne_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ne_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ne_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ne_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_always_ne_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_always_ne_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ne_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_always_ne_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_ne_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_always_ne_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_ne_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_always_ne_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ne_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_always_ne_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_ne_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_always_ne_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("aNe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_ne_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("%<>", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_always_ne_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_eq_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_eq_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_eq_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_eq_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_eq_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_eq_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_ever_eq_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_ever_eq_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_eq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_eq_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_eq_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_eq_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_eq_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_eq_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_eq_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_eq_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_eq_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_eq_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_eq_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eEq", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_eq_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_eq_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ge_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ge_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ge_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ge_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ge_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ge_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_ge_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_ge_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_ge_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_ge_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ge_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ge_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_ge_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_ge_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_ge_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_ge_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_gt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_gt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_gt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_gt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_gt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_gt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_gt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_gt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_gt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_gt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_gt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_gt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_gt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_gt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_gt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eGt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_gt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?>", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_gt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_le_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_le_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_le_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_le_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_le_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_le_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_le_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_le_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_le_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_le_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_le_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_le_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_le_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_le_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_le_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_le_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<=", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_le_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_lt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_lt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_lt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_lt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_lt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_lt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_lt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_lt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_lt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_lt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_lt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_lt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_lt_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_lt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_lt_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eLt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_lt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_lt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_ne_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_ne_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ne_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ne_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ne_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {LogicalType::INTEGER, TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ne_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_ever_ne_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, Gen_ever_ne_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ne_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {LogicalType::VARCHAR, TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_ever_ne_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_ne_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, Gen_ever_ne_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_ne_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::BOOLEAN, Gen_ever_ne_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ne_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {LogicalType::BIGINT, TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_ever_ne_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_ne_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::tbigint(), LogicalType::BIGINT}, LogicalType::BOOLEAN, Gen_ever_ne_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eNe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_ne_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("?<>", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, Gen_ever_ne_ttext_text)); +} + +static void RegisterGenerated_meos_temporal_comp_temp(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_teq_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_teq_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_teq_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_teq_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_teq_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_teq_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_teq_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_teq_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tEq", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_teq_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tge_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tge_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_tge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tge_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tge_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tge_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_tge_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tge_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tgt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tgt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tgt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_tgt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tgt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tgt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tgt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tgt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_tgt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tGt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tgt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tle_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tle_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tle_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_tle_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tle_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tle_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tle_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tle_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_tle_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tle_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tlt_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tlt_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tlt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_tlt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tlt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tlt_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tlt_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tlt_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_tlt_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tLt", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tlt_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tne_bool_tbool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tne_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tne_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tne_tbool_bool)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, TemporalTypes::tbool(), Gen_tne_temporal_temporal)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::tbool(), Gen_tne_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tbool(), Gen_tne_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tbool(), Gen_tne_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tNe", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tne_ttext_text)); +} + +static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::tbool(), TemporalTypes::tbool()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TemporalTypes::ttext(), TemporalTypes::ttext()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, LogicalType::BOOLEAN, Gen_temporal_ne)); +} + +static void RegisterGenerated_meos_temporal_constructor(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {LogicalType::LIST(TemporalTypes::tbool())}, TemporalTypes::tbool(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {LogicalType::LIST(TemporalTypes::tbool()), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {LogicalType::LIST(TemporalTypes::tbool()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {LogicalType::LIST(TemporalTypes::tbool()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {LogicalType::LIST(TemporalTypes::tint())}, TemporalTypes::tint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {LogicalType::LIST(TemporalTypes::tint()), LogicalType::VARCHAR}, TemporalTypes::tint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {LogicalType::LIST(TemporalTypes::tint()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {LogicalType::LIST(TemporalTypes::tint()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {LogicalType::LIST(TemporalTypes::tbigint())}, TemporalTypes::tbigint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {LogicalType::LIST(TemporalTypes::tbigint()), LogicalType::VARCHAR}, TemporalTypes::tbigint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {LogicalType::LIST(TemporalTypes::tbigint()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {LogicalType::LIST(TemporalTypes::tbigint()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {LogicalType::LIST(TemporalTypes::tfloat())}, TemporalTypes::tfloat(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {LogicalType::LIST(TemporalTypes::ttext())}, TemporalTypes::ttext(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {LogicalType::LIST(TemporalTypes::ttext()), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {LogicalType::LIST(TemporalTypes::ttext()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {LogicalType::LIST(TemporalTypes::ttext()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_tsequence_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeqSet", {LogicalType::LIST(TemporalTypes::tbool())}, TemporalTypes::tbool(), Gen_tsequenceset_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeqSet", {LogicalType::LIST(TemporalTypes::tint())}, TemporalTypes::tint(), Gen_tsequenceset_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeqSet", {LogicalType::LIST(TemporalTypes::tbigint())}, TemporalTypes::tbigint(), Gen_tsequenceset_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSet", {LogicalType::LIST(TemporalTypes::tfloat())}, TemporalTypes::tfloat(), Gen_tsequenceset_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeqSet", {LogicalType::LIST(TemporalTypes::ttext())}, TemporalTypes::ttext(), Gen_tsequenceset_make)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeqSetGaps", {LogicalType::LIST(TemporalTypes::tbool())}, TemporalTypes::tbool(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeqSetGaps", {LogicalType::LIST(TemporalTypes::tbool()), LogicalType::INTERVAL}, TemporalTypes::tbool(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tint())}, TemporalTypes::tint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tint()), LogicalType::INTERVAL}, TemporalTypes::tint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tint()), LogicalType::INTERVAL, LogicalType::DOUBLE}, TemporalTypes::tint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tbigint())}, TemporalTypes::tbigint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tbigint()), LogicalType::INTERVAL}, TemporalTypes::tbigint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeqSetGaps", {LogicalType::LIST(TemporalTypes::tbigint()), LogicalType::INTERVAL, LogicalType::DOUBLE}, TemporalTypes::tbigint(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSetGaps", {LogicalType::LIST(TemporalTypes::tfloat())}, TemporalTypes::tfloat(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSetGaps", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::INTERVAL}, TemporalTypes::tfloat(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSetGaps", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::INTERVAL, LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSetGaps", {LogicalType::LIST(TemporalTypes::tfloat()), LogicalType::INTERVAL, LogicalType::DOUBLE, LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeqSetGaps", {LogicalType::LIST(TemporalTypes::ttext())}, TemporalTypes::ttext(), Gen_tsequenceset_make_gaps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeqSetGaps", {LogicalType::LIST(TemporalTypes::ttext()), LogicalType::INTERVAL}, TemporalTypes::ttext(), Gen_tsequenceset_make_gaps)); +} + +static void RegisterGenerated_meos_temporal_conversion(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tint", {TemporalTypes::tbool()}, TemporalTypes::tint(), Gen_tbool_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbool()}, TemporalTypes::tint(), Gen_tbool_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tint", {TemporalTypes::tfloat()}, TemporalTypes::tint(), Gen_tfloat_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tfloat()}, TemporalTypes::tint(), Gen_tfloat_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigint", {TemporalTypes::tfloat()}, TemporalTypes::tbigint(), Gen_tfloat_to_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tfloat()}, TemporalTypes::tbigint(), Gen_tfloat_to_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloat", {TemporalTypes::tint()}, TemporalTypes::tfloat(), Gen_tint_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tint()}, TemporalTypes::tfloat(), Gen_tint_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigint", {TemporalTypes::tint()}, TemporalTypes::tbigint(), Gen_tint_to_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tint()}, TemporalTypes::tbigint(), Gen_tint_to_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tint", {TemporalTypes::tbigint()}, TemporalTypes::tint(), Gen_tbigint_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, TemporalTypes::tint(), Gen_tbigint_to_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloat", {TemporalTypes::tbigint()}, TemporalTypes::tfloat(), Gen_tbigint_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, TemporalTypes::tfloat(), Gen_tbigint_to_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {CbufferTypes::tcbuffer()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {CbufferTypes::tcbuffer()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TGeometryTypes::tgeometry()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeometryTypes::tgeometry()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TGeographyTypes::tgeography()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TGeographyTypes::tgeography()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TgeompointType::tgeompoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TgeompointType::tgeompoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TgeogpointType::tgeogpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TgeogpointType::tgeogpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tbool()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbool()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tbigint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tfloat()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tfloat()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::ttext()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::ttext()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("valueSpan", {TemporalTypes::tint()}, SpanTypes::intspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tint()}, SpanTypes::intspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("valueSpan", {TemporalTypes::tbigint()}, SpanTypes::bigintspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, SpanTypes::bigintspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("valueSpan", {TemporalTypes::tfloat()}, SpanTypes::floatspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tfloat()}, SpanTypes::floatspan(), Gen_tnumber_to_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbox", {TemporalTypes::tint()}, TboxType::tbox(), Gen_tnumber_to_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tint()}, TboxType::tbox(), Gen_tnumber_to_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbox", {TemporalTypes::tbigint()}, TboxType::tbox(), Gen_tnumber_to_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tbigint()}, TboxType::tbox(), Gen_tnumber_to_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbox", {TemporalTypes::tfloat()}, TboxType::tbox(), Gen_tnumber_to_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TemporalTypes::tfloat()}, TboxType::tbox(), Gen_tnumber_to_tbox)); +} + +static void RegisterGenerated_meos_temporal_dist(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tdistance_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tdistance_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tfloat(), Gen_tdistance_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tfloat(), Gen_tdistance_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tfloat(), Gen_tdistance_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tfloat(), Gen_tdistance_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tdistance_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tdistance_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, Gen_nad_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, Gen_nad_tfloat_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::INTEGER, Gen_nad_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, Gen_nad_tint_tint)); +} + +static void RegisterGenerated_meos_temporal_inout(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TGeometryTypes::tgeometry(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TGeographyTypes::tgeography(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TgeompointType::tgeompoint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TgeompointType::tgeompoint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TgeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TgeogpointType::tgeogpoint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbool()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbool(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbigint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tbigint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tfloat()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::tfloat(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::ttext()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TemporalTypes::ttext(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolFromHexWKB", {LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_temporal_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintFromHexWKB", {LogicalType::VARCHAR}, TemporalTypes::tint(), Gen_temporal_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintFromHexWKB", {LogicalType::VARCHAR}, TemporalTypes::tbigint(), Gen_temporal_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatFromHexWKB", {LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_temporal_from_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextFromHexWKB", {LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_temporal_from_hexwkb)); +} + +static void RegisterGenerated_meos_temporal_math(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_add_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_add_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_add_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_add_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_add_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_add_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_add_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_add_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_add_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_add_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_add_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_add_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_add_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_add_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tAdd", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_add_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_add_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_div_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_div_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_div_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_div_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_div_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_div_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_div_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_div_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_div_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_div_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tDiv", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_div_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_div_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_mul_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_mul_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_mul_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_mul_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_mul_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_mul_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_mul_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_mul_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_mul_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_mul_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_mul_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_mul_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_mul_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_mul_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tMul", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_mul_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_mul_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_sub_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_sub_float_tfloat)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_sub_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), Gen_sub_int_tint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_sub_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_sub_tfloat_float)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_sub_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_sub_tint_int)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_sub_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::BIGINT, TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_sub_bigint_tbigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_sub_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_sub_tbigint_bigint)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_sub_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_sub_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tSub", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_sub_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_sub_tnumber_tnumber)); + RegisterSerializedScalarFunction(loader, ScalarFunction("derivative", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_derivative)); + RegisterSerializedScalarFunction(loader, ScalarFunction("exp", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_exp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ln", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_ln)); + RegisterSerializedScalarFunction(loader, ScalarFunction("log10", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_log10)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sin", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_sin)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cos", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_cos)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tan", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_tan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("abs", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_tnumber_abs)); + RegisterSerializedScalarFunction(loader, ScalarFunction("abs", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tnumber_abs)); + RegisterSerializedScalarFunction(loader, ScalarFunction("trend", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_tnumber_trend)); + RegisterSerializedScalarFunction(loader, ScalarFunction("trend", {TemporalTypes::tfloat()}, TemporalTypes::tint(), Gen_tnumber_trend)); + RegisterSerializedScalarFunction(loader, ScalarFunction("angularDifference", {TemporalTypes::tint()}, TemporalTypes::tfloat(), Gen_tnumber_angular_difference)); + RegisterSerializedScalarFunction(loader, ScalarFunction("angularDifference", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tnumber_angular_difference)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deltaValue", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_tnumber_delta_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deltaValue", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tnumber_delta_value)); +} + +static void RegisterGenerated_meos_temporal_modif(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TemporalTypes::tfloat(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TemporalTypes::ttext(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TgeompointType::tgeompoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TgeogpointType::tgeogpoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeogpointType::tgeogpoint(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TGeometryTypes::tgeometry(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {TGeographyTypes::tgeography(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeographyTypes::tgeography(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("deleteTime", {CbufferTypes::tcbuffer(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, CbufferTypes::tcbuffer(), Gen_temporal_delete_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("insert", {TemporalTypes::tint(), TemporalTypes::tint(), LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_insert)); + RegisterSerializedScalarFunction(loader, ScalarFunction("insert", {TemporalTypes::tbigint(), TemporalTypes::tbigint(), LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_insert)); + RegisterSerializedScalarFunction(loader, ScalarFunction("insert", {TemporalTypes::tbool(), TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_insert)); + RegisterSerializedScalarFunction(loader, ScalarFunction("insert", {TemporalTypes::tfloat(), TemporalTypes::tfloat(), LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_insert)); + RegisterSerializedScalarFunction(loader, ScalarFunction("insert", {TemporalTypes::ttext(), TemporalTypes::ttext(), LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_temporal_insert)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("merge", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_merge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TemporalTypes::tint(), TemporalTypes::tint(), LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TemporalTypes::tbigint(), TemporalTypes::tbigint(), LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TemporalTypes::tbool(), TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TemporalTypes::tfloat(), TemporalTypes::tfloat(), LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TemporalTypes::ttext(), TemporalTypes::ttext(), LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TgeompointType::tgeompoint(), TgeompointType::tgeompoint(), LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TgeogpointType::tgeogpoint(), TgeogpointType::tgeogpoint(), LogicalType::BOOLEAN}, TgeogpointType::tgeogpoint(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry(), LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {TGeographyTypes::tgeography(), TGeographyTypes::tgeography(), LogicalType::BOOLEAN}, TGeographyTypes::tgeography(), Gen_temporal_update)); + RegisterSerializedScalarFunction(loader, ScalarFunction("update", {CbufferTypes::tcbuffer(), CbufferTypes::tcbuffer(), LogicalType::BOOLEAN}, CbufferTypes::tcbuffer(), Gen_temporal_update)); +} + +static void RegisterGenerated_meos_temporal_restrict(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tbool_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_tbool_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TemporalTypes::tfloat(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TemporalTypes::ttext(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TgeompointType::tgeompoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TgeogpointType::tgeogpoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeogpointType::tgeogpoint(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TGeometryTypes::tgeometry(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {TGeographyTypes::tgeography(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeographyTypes::tgeography(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("afterTimestamp", {CbufferTypes::tcbuffer(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, CbufferTypes::tcbuffer(), Gen_temporal_after_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMax", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_at_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMax", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_at_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMax", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_at_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMax", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_at_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMin", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_at_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMin", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_at_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMin", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_at_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atMin", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_at_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tint(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tbigint(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tbool(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tfloat(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tfloat(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::ttext(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::ttext(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeompointType::tgeompoint(), LogicalType::TIMESTAMP_TZ}, TgeompointType::tgeompoint(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeogpointType::tgeogpoint(), LogicalType::TIMESTAMP_TZ}, TgeogpointType::tgeogpoint(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeometryTypes::tgeometry(), LogicalType::TIMESTAMP_TZ}, TGeometryTypes::tgeometry(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeographyTypes::tgeography(), LogicalType::TIMESTAMP_TZ}, TGeographyTypes::tgeography(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {CbufferTypes::tcbuffer(), LogicalType::TIMESTAMP_TZ}, CbufferTypes::tcbuffer(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tint(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbigint(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tbool(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::tfloat(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TemporalTypes::ttext(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TemporalTypes::ttext(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TgeompointType::tgeompoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeompointType::tgeompoint(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TgeogpointType::tgeogpoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TgeogpointType::tgeogpoint(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TGeometryTypes::tgeometry(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeometryTypes::tgeometry(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {TGeographyTypes::tgeography(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, TGeographyTypes::tgeography(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("beforeTimestamp", {CbufferTypes::tcbuffer(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, CbufferTypes::tcbuffer(), Gen_temporal_before_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMax", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_minus_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMax", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_minus_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMax", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_minus_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMax", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_minus_max)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMin", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_minus_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMin", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_minus_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMin", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_minus_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusMin", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_minus_min)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tint(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tint(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbigint(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tbigint(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbool(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tbool(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tfloat(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::tfloat(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::ttext(), LogicalType::TIMESTAMP_TZ}, TemporalTypes::ttext(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeompointType::tgeompoint(), LogicalType::TIMESTAMP_TZ}, TgeompointType::tgeompoint(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeogpointType::tgeogpoint(), LogicalType::TIMESTAMP_TZ}, TgeogpointType::tgeogpoint(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeometryTypes::tgeometry(), LogicalType::TIMESTAMP_TZ}, TGeometryTypes::tgeometry(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeographyTypes::tgeography(), LogicalType::TIMESTAMP_TZ}, TGeographyTypes::tgeography(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {CbufferTypes::tcbuffer(), LogicalType::TIMESTAMP_TZ}, CbufferTypes::tcbuffer(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_ttext_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_ttext_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tint(), SetTypes::tstzset()}, TemporalTypes::tint(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbigint(), SetTypes::tstzset()}, TemporalTypes::tbigint(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbool(), SetTypes::tstzset()}, TemporalTypes::tbool(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tfloat(), SetTypes::tstzset()}, TemporalTypes::tfloat(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::ttext(), SetTypes::tstzset()}, TemporalTypes::ttext(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeompointType::tgeompoint(), SetTypes::tstzset()}, TgeompointType::tgeompoint(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeogpointType::tgeogpoint(), SetTypes::tstzset()}, TgeogpointType::tgeogpoint(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeometryTypes::tgeometry(), SetTypes::tstzset()}, TGeometryTypes::tgeometry(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeographyTypes::tgeography(), SetTypes::tstzset()}, TGeographyTypes::tgeography(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {CbufferTypes::tcbuffer(), SetTypes::tstzset()}, CbufferTypes::tcbuffer(), Gen_temporal_at_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tint(), SpanTypes::tstzspan()}, TemporalTypes::tint(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, TemporalTypes::tbigint(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, TemporalTypes::tbool(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, TemporalTypes::tfloat(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, TemporalTypes::ttext(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, TgeompointType::tgeompoint(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, TgeogpointType::tgeogpoint(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, TGeometryTypes::tgeometry(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, TGeographyTypes::tgeography(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, CbufferTypes::tcbuffer(), Gen_temporal_at_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tint(), SpansetTypes::tstzspanset()}, TemporalTypes::tint(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbigint(), SpansetTypes::tstzspanset()}, TemporalTypes::tbigint(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tbool(), SpansetTypes::tstzspanset()}, TemporalTypes::tbool(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::tfloat(), SpansetTypes::tstzspanset()}, TemporalTypes::tfloat(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TemporalTypes::ttext(), SpansetTypes::tstzspanset()}, TemporalTypes::ttext(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeompointType::tgeompoint(), SpansetTypes::tstzspanset()}, TgeompointType::tgeompoint(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TgeogpointType::tgeogpoint(), SpansetTypes::tstzspanset()}, TgeogpointType::tgeogpoint(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeometryTypes::tgeometry(), SpansetTypes::tstzspanset()}, TGeometryTypes::tgeometry(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TGeographyTypes::tgeography(), SpansetTypes::tstzspanset()}, TGeographyTypes::tgeography(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {CbufferTypes::tcbuffer(), SpansetTypes::tstzspanset()}, CbufferTypes::tcbuffer(), Gen_temporal_at_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tint(), SetTypes::tstzset()}, TemporalTypes::tint(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbigint(), SetTypes::tstzset()}, TemporalTypes::tbigint(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbool(), SetTypes::tstzset()}, TemporalTypes::tbool(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tfloat(), SetTypes::tstzset()}, TemporalTypes::tfloat(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::ttext(), SetTypes::tstzset()}, TemporalTypes::ttext(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeompointType::tgeompoint(), SetTypes::tstzset()}, TgeompointType::tgeompoint(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeogpointType::tgeogpoint(), SetTypes::tstzset()}, TgeogpointType::tgeogpoint(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeometryTypes::tgeometry(), SetTypes::tstzset()}, TGeometryTypes::tgeometry(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeographyTypes::tgeography(), SetTypes::tstzset()}, TGeographyTypes::tgeography(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {CbufferTypes::tcbuffer(), SetTypes::tstzset()}, CbufferTypes::tcbuffer(), Gen_temporal_minus_tstzset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tint(), SpanTypes::tstzspan()}, TemporalTypes::tint(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbigint(), SpanTypes::tstzspan()}, TemporalTypes::tbigint(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbool(), SpanTypes::tstzspan()}, TemporalTypes::tbool(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tfloat(), SpanTypes::tstzspan()}, TemporalTypes::tfloat(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::ttext(), SpanTypes::tstzspan()}, TemporalTypes::ttext(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeompointType::tgeompoint(), SpanTypes::tstzspan()}, TgeompointType::tgeompoint(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeogpointType::tgeogpoint(), SpanTypes::tstzspan()}, TgeogpointType::tgeogpoint(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeometryTypes::tgeometry(), SpanTypes::tstzspan()}, TGeometryTypes::tgeometry(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeographyTypes::tgeography(), SpanTypes::tstzspan()}, TGeographyTypes::tgeography(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {CbufferTypes::tcbuffer(), SpanTypes::tstzspan()}, CbufferTypes::tcbuffer(), Gen_temporal_minus_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tint(), SpansetTypes::tstzspanset()}, TemporalTypes::tint(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbigint(), SpansetTypes::tstzspanset()}, TemporalTypes::tbigint(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tbool(), SpansetTypes::tstzspanset()}, TemporalTypes::tbool(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::tfloat(), SpansetTypes::tstzspanset()}, TemporalTypes::tfloat(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TemporalTypes::ttext(), SpansetTypes::tstzspanset()}, TemporalTypes::ttext(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeompointType::tgeompoint(), SpansetTypes::tstzspanset()}, TgeompointType::tgeompoint(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TgeogpointType::tgeogpoint(), SpansetTypes::tstzspanset()}, TgeogpointType::tgeogpoint(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeometryTypes::tgeometry(), SpansetTypes::tstzspanset()}, TGeometryTypes::tgeometry(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TGeographyTypes::tgeography(), SpansetTypes::tstzspanset()}, TGeographyTypes::tgeography(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {CbufferTypes::tcbuffer(), SpansetTypes::tstzspanset()}, CbufferTypes::tcbuffer(), Gen_temporal_minus_tstzspanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValues", {TemporalTypes::tint(), SetTypes::intset()}, TemporalTypes::tint(), Gen_temporal_at_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValues", {TemporalTypes::tbigint(), SetTypes::bigintset()}, TemporalTypes::tbigint(), Gen_temporal_at_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValues", {TemporalTypes::tfloat(), SetTypes::floatset()}, TemporalTypes::tfloat(), Gen_temporal_at_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValues", {TemporalTypes::ttext(), SetTypes::textset()}, TemporalTypes::ttext(), Gen_temporal_at_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValues", {TemporalTypes::tint(), SetTypes::intset()}, TemporalTypes::tint(), Gen_temporal_minus_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValues", {TemporalTypes::tbigint(), SetTypes::bigintset()}, TemporalTypes::tbigint(), Gen_temporal_minus_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValues", {TemporalTypes::tfloat(), SetTypes::floatset()}, TemporalTypes::tfloat(), Gen_temporal_minus_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValues", {TemporalTypes::ttext(), SetTypes::textset()}, TemporalTypes::ttext(), Gen_temporal_minus_values)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpan", {TemporalTypes::tint(), SpanTypes::intspan()}, TemporalTypes::tint(), Gen_tnumber_at_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpan", {TemporalTypes::tbigint(), SpanTypes::bigintspan()}, TemporalTypes::tbigint(), Gen_tnumber_at_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpan", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, TemporalTypes::tfloat(), Gen_tnumber_at_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpanset", {TemporalTypes::tint(), SpansetTypes::intspanset()}, TemporalTypes::tint(), Gen_tnumber_at_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpanset", {TemporalTypes::tbigint(), SpansetTypes::bigintspanset()}, TemporalTypes::tbigint(), Gen_tnumber_at_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atSpanset", {TemporalTypes::tfloat(), SpansetTypes::floatspanset()}, TemporalTypes::tfloat(), Gen_tnumber_at_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTbox", {TemporalTypes::tint(), TboxType::tbox()}, TemporalTypes::tint(), Gen_tnumber_at_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTbox", {TemporalTypes::tbigint(), TboxType::tbox()}, TemporalTypes::tbigint(), Gen_tnumber_at_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTbox", {TemporalTypes::tfloat(), TboxType::tbox()}, TemporalTypes::tfloat(), Gen_tnumber_at_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpan", {TemporalTypes::tint(), SpanTypes::intspan()}, TemporalTypes::tint(), Gen_tnumber_minus_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpan", {TemporalTypes::tbigint(), SpanTypes::bigintspan()}, TemporalTypes::tbigint(), Gen_tnumber_minus_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpan", {TemporalTypes::tfloat(), SpanTypes::floatspan()}, TemporalTypes::tfloat(), Gen_tnumber_minus_span)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpanset", {TemporalTypes::tint(), SpansetTypes::intspanset()}, TemporalTypes::tint(), Gen_tnumber_minus_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpanset", {TemporalTypes::tbigint(), SpansetTypes::bigintspanset()}, TemporalTypes::tbigint(), Gen_tnumber_minus_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusSpanset", {TemporalTypes::tfloat(), SpansetTypes::floatspanset()}, TemporalTypes::tfloat(), Gen_tnumber_minus_spanset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTbox", {TemporalTypes::tint(), TboxType::tbox()}, TemporalTypes::tint(), Gen_tnumber_minus_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTbox", {TemporalTypes::tbigint(), TboxType::tbox()}, TemporalTypes::tbigint(), Gen_tnumber_minus_tbox)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTbox", {TemporalTypes::tfloat(), TboxType::tbox()}, TemporalTypes::tfloat(), Gen_tnumber_minus_tbox)); +} + +static void RegisterGenerated_meos_temporal_spatial_rel_ever(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("aTouches", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_atouches_tpoint_geo)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eTouches", {TgeompointType::tgeompoint(), GeoTypes::GEOMETRY()}, LogicalType::BOOLEAN, Gen_etouches_tpoint_geo)); +} + +static void RegisterGenerated_meos_temporal_text(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("textcat", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_textcat_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("||", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_textcat_text_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("textcat", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_textcat_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_textcat_ttext_text)); + RegisterSerializedScalarFunction(loader, ScalarFunction("textcat", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_textcat_ttext_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_textcat_ttext_ttext)); + RegisterSerializedScalarFunction(loader, ScalarFunction("initcap", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_ttext_initcap)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_ttext_upper)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_ttext_lower)); +} + +static void RegisterGenerated_meos_temporal_transf(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TemporalTypes::tfloat(), LogicalType::INTEGER}, TemporalTypes::tfloat(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TgeompointType::tgeompoint(), LogicalType::INTEGER}, TgeompointType::tgeompoint(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TgeogpointType::tgeogpoint(), LogicalType::INTEGER}, TgeogpointType::tgeogpoint(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, TGeometryTypes::tgeometry(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TGeographyTypes::tgeography(), LogicalType::INTEGER}, TGeographyTypes::tgeography(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {CbufferTypes::tcbuffer(), LogicalType::INTEGER}, CbufferTypes::tcbuffer(), Gen_temporal_round)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TgeompointType::tgeompoint()}, TgeompointType::tgeompoint(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TgeogpointType::tgeogpoint()}, TgeogpointType::tgeogpoint(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TGeometryTypes::tgeometry()}, TGeometryTypes::tgeometry(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {TGeographyTypes::tgeography()}, TGeographyTypes::tgeography(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("round", {CbufferTypes::tcbuffer()}, CbufferTypes::tcbuffer(), Gen_temporal_round_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolInst", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_to_tinstant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintInst", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_to_tinstant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintInst", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_to_tinstant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatInst", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_to_tinstant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextInst", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_to_tinstant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeq", {TemporalTypes::tbool(), LogicalType::VARCHAR}, TemporalTypes::tbool(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeq", {TemporalTypes::tint(), LogicalType::VARCHAR}, TemporalTypes::tint(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeq", {TemporalTypes::tbigint(), LogicalType::VARCHAR}, TemporalTypes::tbigint(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeq", {TemporalTypes::tfloat(), LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeq", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), Gen_temporal_to_tsequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tboolSeqSet", {TemporalTypes::tbool()}, TemporalTypes::tbool(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tintSeqSet", {TemporalTypes::tint()}, TemporalTypes::tint(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tbigintSeqSet", {TemporalTypes::tbigint()}, TemporalTypes::tbigint(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSet", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tfloatSeqSet", {TemporalTypes::tfloat(), LogicalType::VARCHAR}, TemporalTypes::tfloat(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ttextSeqSet", {TemporalTypes::ttext()}, TemporalTypes::ttext(), Gen_temporal_to_tsequenceset)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ceil", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_ceil)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {TemporalTypes::tfloat(), LogicalType::BOOLEAN}, TemporalTypes::tfloat(), Gen_tfloat_degrees)); + RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_degrees_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("floor", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_floor)); + RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {TemporalTypes::tfloat()}, TemporalTypes::tfloat(), Gen_tfloat_radians)); + RegisterSerializedScalarFunction(loader, ScalarFunction("scaleValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftScaleValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE, LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_shift_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftValue", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), Gen_tfloat_shift_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("scaleValue", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("scaleValue", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_tbigint_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftScaleValue", {TemporalTypes::tint(), LogicalType::INTEGER, LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_shift_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftScaleValue", {TemporalTypes::tbigint(), LogicalType::BIGINT, LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_tbigint_shift_scale_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftValue", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), Gen_tint_shift_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("shiftValue", {TemporalTypes::tbigint(), LogicalType::BIGINT}, TemporalTypes::tbigint(), Gen_tbigint_shift_value)); +} + +void RegisterGeneratedTemporalUdfs(ExtensionLoader &loader) { + RegisterGenerated_meos_box_bbox_pos(loader); + RegisterGenerated_meos_box_bbox_topo(loader); + RegisterGenerated_meos_box_comp(loader); + RegisterGenerated_meos_box_set(loader); + RegisterGenerated_meos_cbuffer_accessor(loader); + RegisterGenerated_meos_cbuffer_comp_ever(loader); + RegisterGenerated_meos_cbuffer_comp_temp(loader); + RegisterGenerated_meos_cbuffer_conversion(loader); + RegisterGenerated_meos_cbuffer_dist(loader); + RegisterGenerated_meos_cbuffer_rel_ever(loader); + RegisterGenerated_meos_cbuffer_rel_temp(loader); + RegisterGenerated_meos_cbuffer_restrict(loader); + RegisterGenerated_meos_cbuffer_transf(loader); + RegisterGenerated_meos_geo_accessor(loader); + RegisterGenerated_meos_geo_bbox_pos(loader); + RegisterGenerated_meos_geo_bbox_topo(loader); + RegisterGenerated_meos_geo_box_comp(loader); + RegisterGenerated_meos_geo_box_pos(loader); + RegisterGenerated_meos_geo_box_set(loader); + RegisterGenerated_meos_geo_box_topo(loader); + RegisterGenerated_meos_geo_comp_ever(loader); + RegisterGenerated_meos_geo_comp_temp(loader); + RegisterGenerated_meos_geo_conversion(loader); + RegisterGenerated_meos_geo_distance(loader); + RegisterGenerated_meos_geo_inout(loader); + RegisterGenerated_meos_geo_rel_ever(loader); + RegisterGenerated_meos_geo_rel_temp(loader); + RegisterGenerated_meos_geo_restrict(loader); + RegisterGenerated_meos_geo_srid(loader); + RegisterGenerated_meos_internal_temporal_inout(loader); + RegisterGenerated_meos_quadbin_conversion(loader); + RegisterGenerated_meos_setspan_accessor(loader); + RegisterGenerated_meos_setspan_bbox_split(loader); + RegisterGenerated_meos_setspan_comp(loader); + RegisterGenerated_meos_setspan_conversion(loader); + RegisterGenerated_meos_setspan_inout(loader); + RegisterGenerated_meos_setspan_pos(loader); + RegisterGenerated_meos_setspan_set(loader); + RegisterGenerated_meos_setspan_topo(loader); + RegisterGenerated_meos_setspan_transf(loader); + RegisterGenerated_meos_temporal_accessor(loader); + RegisterGenerated_meos_temporal_analytics_similarity(loader); + RegisterGenerated_meos_temporal_analytics_simplify(loader); + RegisterGenerated_meos_temporal_bbox_pos(loader); + RegisterGenerated_meos_temporal_bbox_split(loader); + RegisterGenerated_meos_temporal_bbox_topo(loader); + RegisterGenerated_meos_temporal_bool(loader); + RegisterGenerated_meos_temporal_comp_ever(loader); + RegisterGenerated_meos_temporal_comp_temp(loader); + RegisterGenerated_meos_temporal_comp_trad(loader); + RegisterGenerated_meos_temporal_constructor(loader); + RegisterGenerated_meos_temporal_conversion(loader); + RegisterGenerated_meos_temporal_dist(loader); + RegisterGenerated_meos_temporal_inout(loader); + RegisterGenerated_meos_temporal_math(loader); + RegisterGenerated_meos_temporal_modif(loader); + RegisterGenerated_meos_temporal_restrict(loader); + RegisterGenerated_meos_temporal_spatial_rel_ever(loader); + RegisterGenerated_meos_temporal_text(loader); + RegisterGenerated_meos_temporal_transf(loader); +} + +} // namespace duckdb diff --git a/src/generated/generated_type_registration.cpp b/src/generated/generated_type_registration.cpp new file mode 100644 index 00000000..6b75f890 --- /dev/null +++ b/src/generated/generated_type_registration.cpp @@ -0,0 +1,183 @@ +// GENERATED by tools/codegen_duck_udfs.py — do not edit by hand. +// Collection type registration (set / span / spanset). The type list of +// each family is the (base-value x container) grid the catalog MeosType +// enum declares, so the orthogonality is mechanical and phantom-free. + +#include "temporal/set.hpp" +#include "temporal/span.hpp" +#include "temporal/spanset.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +extern "C" { + #include + #include +} + +namespace duckdb { + +// --- SpansetTypes: 5 type(s) from the catalog MeosType enum --- +#define DEFINE_SPAN_SET_TYPE(NAME) \ + LogicalType SpansetTypes::NAME() { \ + auto type = LogicalType(LogicalTypeId::BLOB); \ + type.SetAlias(#NAME); \ + return type; \ + } +DEFINE_SPAN_SET_TYPE(intspanset) +DEFINE_SPAN_SET_TYPE(bigintspanset) +DEFINE_SPAN_SET_TYPE(floatspanset) +DEFINE_SPAN_SET_TYPE(datespanset) +DEFINE_SPAN_SET_TYPE(tstzspanset) +#undef DEFINE_SPAN_SET_TYPE + +void SpansetTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType("intspanset", intspanset()); + loader.RegisterType("bigintspanset", bigintspanset()); + loader.RegisterType("floatspanset", floatspanset()); + loader.RegisterType("datespanset", datespanset()); + loader.RegisterType("tstzspanset", tstzspanset()); +} + +const std::vector &SpansetTypes::AllTypes() { + static std::vector types = { + intspanset(), bigintspanset(), floatspanset(), datespanset(), tstzspanset() + }; + return types; +} + +MeosType SpansetTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { + static const std::unordered_map alias_to_type = { + {"intspanset", T_INTSPANSET}, {"bigintspanset", T_BIGINTSPANSET}, {"floatspanset", T_FLOATSPANSET}, {"datespanset", T_DATESPANSET}, {"tstzspanset", T_TSTZSPANSET} + }; + auto it = alias_to_type.find(alias); + return it != alias_to_type.end() ? it->second : T_UNKNOWN; +} + +LogicalType SpansetTypeMapping::GetChildType(const LogicalType &type) { + auto alias = type.ToString(); + if (alias == "intspanset") return SpanTypes::intspan(); + if (alias == "bigintspanset") return SpanTypes::bigintspan(); + if (alias == "floatspanset") return SpanTypes::floatspan(); + if (alias == "datespanset") return SpanTypes::datespan(); + if (alias == "tstzspanset") return SpanTypes::tstzspan(); + throw NotImplementedException("GetChildType: unsupported alias: " + alias); +} + +LogicalType SpansetTypeMapping::GetSetType(const LogicalType &type) { + auto alias = type.ToString(); + if (alias == "intspanset") return SetTypes::intset(); + if (alias == "bigintspanset") return SetTypes::bigintset(); + if (alias == "floatspanset") return SetTypes::floatset(); + if (alias == "datespanset") return SetTypes::dateset(); + if (alias == "tstzspanset") return SetTypes::tstzset(); + throw NotImplementedException("GetSetType: unsupported alias: " + alias); +} + +LogicalType SpansetTypeMapping::GetBaseType(const LogicalType &type) { + auto alias = type.ToString(); + if (alias == "intspanset") return LogicalType::INTEGER; + if (alias == "bigintspanset") return LogicalType::BIGINT; + if (alias == "floatspanset") return LogicalType::DOUBLE; + if (alias == "datespanset") return LogicalType::DATE; + if (alias == "tstzspanset") return LogicalType::TIMESTAMP_TZ; + throw NotImplementedException("GetBaseType: unsupported alias: " + alias); +} + +// --- SpanTypes: 5 type(s) from the catalog MeosType enum --- +#define DEFINE_SPAN_TYPE(NAME) \ + LogicalType SpanTypes::NAME() { \ + auto type = LogicalType(LogicalTypeId::BLOB); \ + type.SetAlias(#NAME); \ + return type; \ + } +DEFINE_SPAN_TYPE(intspan) +DEFINE_SPAN_TYPE(bigintspan) +DEFINE_SPAN_TYPE(floatspan) +DEFINE_SPAN_TYPE(datespan) +DEFINE_SPAN_TYPE(tstzspan) +#undef DEFINE_SPAN_TYPE + +void SpanTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType("intspan", intspan()); + loader.RegisterType("bigintspan", bigintspan()); + loader.RegisterType("floatspan", floatspan()); + loader.RegisterType("datespan", datespan()); + loader.RegisterType("tstzspan", tstzspan()); +} + +const std::vector &SpanTypes::AllTypes() { + static std::vector types = { + intspan(), bigintspan(), floatspan(), datespan(), tstzspan() + }; + return types; +} + +MeosType SpanTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { + static const std::unordered_map alias_to_type = { + {"intspan", T_INTSPAN}, {"bigintspan", T_BIGINTSPAN}, {"floatspan", T_FLOATSPAN}, {"datespan", T_DATESPAN}, {"tstzspan", T_TSTZSPAN} + }; + auto it = alias_to_type.find(alias); + return it != alias_to_type.end() ? it->second : T_UNKNOWN; +} + +LogicalType SpanTypeMapping::GetChildType(const LogicalType &type) { + auto alias = type.ToString(); + if (alias == "intspan") return LogicalType::INTEGER; + if (alias == "bigintspan") return LogicalType::BIGINT; + if (alias == "floatspan") return LogicalType::DOUBLE; + if (alias == "datespan") return LogicalType::DATE; + if (alias == "tstzspan") return LogicalType::TIMESTAMP_TZ; + throw NotImplementedException("GetChildType: unsupported alias: " + alias); +} + +// --- SetTypes: 6 type(s) from the catalog MeosType enum --- +#define DEFINE_SET_TYPE(NAME) \ + LogicalType SetTypes::NAME() { \ + auto type = LogicalType(LogicalTypeId::BLOB); \ + type.SetAlias(#NAME); \ + return type; \ + } +DEFINE_SET_TYPE(intset) +DEFINE_SET_TYPE(bigintset) +DEFINE_SET_TYPE(floatset) +DEFINE_SET_TYPE(textset) +DEFINE_SET_TYPE(dateset) +DEFINE_SET_TYPE(tstzset) +#undef DEFINE_SET_TYPE + +void SetTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType("intset", intset()); + loader.RegisterType("bigintset", bigintset()); + loader.RegisterType("floatset", floatset()); + loader.RegisterType("textset", textset()); + loader.RegisterType("dateset", dateset()); + loader.RegisterType("tstzset", tstzset()); +} + +const std::vector &SetTypes::AllTypes() { + static std::vector types = { + intset(), bigintset(), floatset(), textset(), dateset(), tstzset() + }; + return types; +} + +MeosType SetTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { + static const std::unordered_map alias_to_type = { + {"intset", T_INTSET}, {"bigintset", T_BIGINTSET}, {"floatset", T_FLOATSET}, {"textset", T_TEXTSET}, {"dateset", T_DATESET}, {"tstzset", T_TSTZSET} + }; + auto it = alias_to_type.find(alias); + return it != alias_to_type.end() ? it->second : T_UNKNOWN; +} + +LogicalType SetTypeMapping::GetChildType(const LogicalType &type) { + auto alias = type.ToString(); + if (alias == "intset") return LogicalType::INTEGER; + if (alias == "bigintset") return LogicalType::BIGINT; + if (alias == "floatset") return LogicalType::DOUBLE; + if (alias == "textset") return LogicalType::VARCHAR; + if (alias == "dateset") return LogicalType::DATE; + if (alias == "tstzset") return LogicalType::TIMESTAMP_TZ; + throw NotImplementedException("GetChildType: unsupported alias: " + alias); +} + +} // namespace duckdb \ No newline at end of file diff --git a/src/geo/geoset.cpp b/src/geo/geoset.cpp index 842045dd..05ab1a6a 100644 --- a/src/geo/geoset.cpp +++ b/src/geo/geoset.cpp @@ -36,12 +36,12 @@ void SpatialSetType::RegisterTypes(ExtensionLoader &loader){ } void SpatialSetType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, SpatialSetType::geomset(), SpatialSetFunctions::Text_to_geoset ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, SpatialSetType::geogset(), SpatialSetFunctions::Text_to_geoset diff --git a/src/geo/spatial_aggregates.cpp b/src/geo/spatial_aggregates.cpp index 27462eaf..997103ca 100644 --- a/src/geo/spatial_aggregates.cpp +++ b/src/geo/spatial_aggregates.cpp @@ -81,7 +81,7 @@ struct TspatialExtentFunction { static AggregateFunction MakeExtentTspatialAggregate(const LogicalType &input_type) { return AggregateFunction::UnaryAggregate( - input_type, StboxType::STBOX()); + input_type, StboxType::stbox()); } // extent(stbox) → stbox — input is a raw STBox blob (not a Temporal wrapper). @@ -275,14 +275,14 @@ static AggregateFunction MakeTcentroidAggregate(const LogicalType &input_type) { } // namespace void SpatialAggregates::AddExtentOverloads(AggregateFunctionSet &extent_set) { - extent_set.AddFunction(MakeExtentTspatialAggregate(TgeompointType::TGEOMPOINT())); + extent_set.AddFunction(MakeExtentTspatialAggregate(TgeompointType::tgeompoint())); extent_set.AddFunction(AggregateFunction::UnaryAggregate( - StboxType::STBOX(), StboxType::STBOX())); + StboxType::stbox(), StboxType::stbox())); } void SpatialAggregates::RegisterTcentroid(ExtensionLoader &loader) { AggregateFunctionSet tcentroid_set("TcentroidAgg"); - tcentroid_set.AddFunction(MakeTcentroidAggregate(TgeompointType::TGEOMPOINT())); + tcentroid_set.AddFunction(MakeTcentroidAggregate(TgeompointType::tgeompoint())); loader.RegisterFunction(std::move(tcentroid_set)); } diff --git a/src/geo/stbox.cpp b/src/geo/stbox.cpp index 8038f09b..42424fc4 100644 --- a/src/geo/stbox.cpp +++ b/src/geo/stbox.cpp @@ -16,70 +16,70 @@ namespace duckdb { -LogicalType StboxType::STBOX() { +LogicalType StboxType::stbox() { LogicalType type(LogicalTypeId::BLOB); - type.SetAlias("STBOX"); + type.SetAlias("stbox"); return type; } void StboxType::RegisterType(ExtensionLoader &loader) { - loader.RegisterType( "STBOX", STBOX()); + loader.RegisterType( "stbox", stbox()); } void StboxType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, - STBOX(), + stbox(), StboxFunctions::Stbox_in_cast ); - loader.RegisterCastFunction( - STBOX(), + RegisterMeosCastFunction(loader, + stbox(), LogicalType::VARCHAR, StboxFunctions::Stbox_out ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, GeoTypes::GEOMETRY(), - STBOX(), + stbox(), StboxFunctions::Geo_to_stbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::TIMESTAMP_TZ, - STBOX(), + stbox(), StboxFunctions::Timestamptz_to_stbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::tstzset(), - STBOX(), + stbox(), StboxFunctions::Tstzset_to_stbox_cast ); - loader.RegisterCastFunction( - SpanTypes::TSTZSPAN(), - STBOX(), + RegisterMeosCastFunction(loader, + SpanTypes::tstzspan(), + stbox(), StboxFunctions::Tstzspan_to_stbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::tstzspanset(), - STBOX(), + stbox(), StboxFunctions::Tstzspanset_to_stbox_cast ); } void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("stbox", {LogicalType::VARCHAR}, STBOX(), StboxFunctions::Stbox_in, nullptr, nullptr, nullptr, + ScalarFunction("stbox", {LogicalType::VARCHAR}, stbox(), StboxFunctions::Stbox_in, nullptr, nullptr, nullptr, nullptr, LogicalType(LogicalTypeId::INVALID), FunctionStability::VOLATILE)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stboxFromBinary", {LogicalType::BLOB}, - STBOX(), + stbox(), StboxFunctions::Stbox_from_wkb ) ); @@ -89,7 +89,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { // ScalarFunction( // "stboxFromHexWKB", // {LogicalType::VARCHAR}, - // STBOX(), + // stbox(), // StboxFunctions::Stbox_from_hexwkb // ) // ); @@ -97,7 +97,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {STBOX()}, + {stbox()}, LogicalType::VARCHAR, StboxFunctions::Stbox_as_text ) @@ -106,7 +106,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asBinary", - {STBOX()}, + {stbox()}, LogicalType::BLOB, StboxFunctions::Stbox_as_wkb ) @@ -116,7 +116,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { // instance, // ScalarFunction( // "asHexWKB", - // {STBOX()}, + // {stbox()}, // LogicalType::VARCHAR, // StboxFunctions::Stbox_as_hexwkb // ) @@ -126,7 +126,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "stbox", {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ}, - StboxType::STBOX(), + StboxType::stbox(), StboxFunctions::Geo_timestamptz_to_stbox ) ); @@ -134,8 +134,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox", - {GeoTypes::GEOMETRY(), SpanTypes::TSTZSPAN()}, - StboxType::STBOX(), + {GeoTypes::GEOMETRY(), SpanTypes::tstzspan()}, + StboxType::stbox(), StboxFunctions::Geo_tstzspan_to_stbox ) ); @@ -144,7 +144,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "stbox", {LogicalType::TIMESTAMP_TZ}, - StboxType::STBOX(), + StboxType::stbox(), StboxFunctions::Timestamptz_to_stbox ) ); @@ -153,7 +153,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "stbox", {SetTypes::tstzset()}, - StboxType::STBOX(), + StboxType::stbox(), StboxFunctions::Tstzset_to_stbox ) ); @@ -161,8 +161,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox", - {SpanTypes::TSTZSPAN()}, - StboxType::STBOX(), + {SpanTypes::tstzspan()}, + StboxType::stbox(), StboxFunctions::Tstzspan_to_stbox ) ); @@ -171,7 +171,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "stbox", {SpansetTypes::tstzspanset()}, - StboxType::STBOX(), + StboxType::stbox(), StboxFunctions::Tstzspanset_to_stbox ) ); @@ -181,7 +181,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "stbox", {GeoTypes::GEOMETRY()}, - StboxType::STBOX(), + StboxType::stbox(), StboxFunctions::Geo_to_stbox ) ); @@ -189,7 +189,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "geometry", - {STBOX()}, + {stbox()}, GeoTypes::GEOMETRY(), StboxFunctions::Stbox_to_geo ) @@ -198,7 +198,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "hasX", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_hasx ) @@ -206,7 +206,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "hasZ", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_hasz ) @@ -214,7 +214,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "hasT", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_hast ) @@ -222,7 +222,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "isGeodetic", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_isgeodetic ) @@ -231,7 +231,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Xmin", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_xmin ) @@ -240,7 +240,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Ymin", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_ymin ) @@ -248,7 +248,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Zmin", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_zmin ) @@ -257,7 +257,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Tmin", - {STBOX()}, + {stbox()}, LogicalType::TIMESTAMP_TZ, StboxFunctions::Stbox_tmin ) @@ -266,7 +266,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "TminInc", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_tmin_inc ) @@ -275,7 +275,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Xmax", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_xmax ) @@ -284,7 +284,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Ymax", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_ymax ) @@ -293,7 +293,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Zmax", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_zmax ) @@ -302,7 +302,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Tmax", - {STBOX()}, + {stbox()}, LogicalType::TIMESTAMP_TZ, StboxFunctions::Stbox_tmax ) @@ -310,7 +310,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "TmaxInc", - {STBOX()}, + {stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_tmax_inc ) @@ -319,7 +319,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "area", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_area ) @@ -328,7 +328,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "volume", - {STBOX()}, + {stbox()}, LogicalType::DOUBLE, StboxFunctions::Stbox_volume ) @@ -337,24 +337,24 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftTime", - {STBOX(), LogicalType::INTERVAL}, - STBOX(), + {stbox(), LogicalType::INTERVAL}, + stbox(), StboxFunctions::Stbox_shift_time ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleTime", - {STBOX(), LogicalType::INTERVAL}, - STBOX(), + {stbox(), LogicalType::INTERVAL}, + stbox(), StboxFunctions::Stbox_scale_time ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleTime", - {STBOX(), LogicalType::INTERVAL, LogicalType::INTERVAL}, - STBOX(), + {stbox(), LogicalType::INTERVAL, LogicalType::INTERVAL}, + stbox(), StboxFunctions::Stbox_shift_scale_time ) ); @@ -362,8 +362,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getSpace", - {STBOX()}, - STBOX(), + {stbox()}, + stbox(), StboxFunctions::Stbox_get_space ) ); @@ -371,8 +371,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "expandTime", - {STBOX(), LogicalType::INTERVAL}, - STBOX(), + {stbox(), LogicalType::INTERVAL}, + stbox(), StboxFunctions::Stbox_expand_time ) ); @@ -380,8 +380,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "expandSpace", - {STBOX(), LogicalType::DOUBLE}, - STBOX(), + {stbox(), LogicalType::DOUBLE}, + stbox(), StboxFunctions::Stbox_expand_space ) ); @@ -389,7 +389,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_contains", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Contains_stbox_stbox ) @@ -398,7 +398,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_contained", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Contained_stbox_stbox ) @@ -406,7 +406,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overlaps", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overlaps_stbox_stbox ) @@ -415,7 +415,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_same", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Same_stbox_stbox ) @@ -423,7 +423,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_adjacent", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Adjacent_stbox_stbox ) @@ -431,7 +431,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "@>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Contains_stbox_stbox ) @@ -439,7 +439,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<@", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Contained_stbox_stbox ) @@ -447,7 +447,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overlaps_stbox_stbox ) @@ -455,7 +455,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "~=", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Same_stbox_stbox ) @@ -463,42 +463,24 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "-|-", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Adjacent_stbox_stbox ) ); - /* *************************************************** - * Tspatial topological predicates (5 ops × 3 type pairs) - * Operators + MobilityDB-canonical named-function aliases. - ****************************************************/ - { - const auto P = TgeompointType::TGEOMPOINT(); - const auto B = STBOX(); - -#define REG_TSPATIAL_TOPO(L, R, FN_SUFFIX) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Contains_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Contains_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Contained_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Contained_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Overlaps_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Overlaps_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Same_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Same_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Adjacent_##FN_SUFFIX)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {L, R}, LogicalType::BOOLEAN, StboxFunctions::Adjacent_##FN_SUFFIX)); - - REG_TSPATIAL_TOPO(P, B, tspatial_stbox) - REG_TSPATIAL_TOPO(B, P, stbox_tspatial) - REG_TSPATIAL_TOPO(P, P, tspatial_tspatial) -#undef REG_TSPATIAL_TOPO - } + /* Tspatial × {stbox, tspatial} topological predicates — the operators + * (~=/@>/<@/&&/-|-) and the canonical bare named functions (same/contains/ + * contained/overlaps/adjacent, the names deployed by MobilityDB's .in.sql) — + * are generated from the MEOS-API catalog; see + * src/generated/generated_temporal_udfs.cpp. (reg_names also registers the + * catalog-only *_bbox @sqlfn backing tag as an alias; that is internal, not a + * user-facing canonical name.) */ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_left", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Left_stbox_stbox ) @@ -507,7 +489,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overleft", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overleft_stbox_stbox ) @@ -515,7 +497,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_right", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Right_stbox_stbox ) @@ -524,7 +506,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overright", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overright_stbox_stbox ) @@ -532,7 +514,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_below", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Below_stbox_stbox ) @@ -540,7 +522,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overbelow", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overbelow_stbox_stbox ) @@ -548,7 +530,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_above", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Above_stbox_stbox ) @@ -557,7 +539,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overabove", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overabove_stbox_stbox ) @@ -566,7 +548,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_before", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Before_stbox_stbox ) @@ -575,7 +557,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overbefore", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overbefore_stbox_stbox ) @@ -584,7 +566,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_after", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::After_stbox_stbox ) @@ -593,7 +575,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overafter", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overafter_stbox_stbox ) @@ -602,7 +584,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_front", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Front_stbox_stbox ) @@ -611,7 +593,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overfront", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overfront_stbox_stbox ) @@ -620,7 +602,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_back", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Back_stbox_stbox ) @@ -629,7 +611,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_overback", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overback_stbox_stbox ) @@ -638,7 +620,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<<", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Left_stbox_stbox ) @@ -647,7 +629,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&<", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overleft_stbox_stbox ) @@ -655,7 +637,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Right_stbox_stbox ) @@ -664,7 +646,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overright_stbox_stbox ) @@ -672,7 +654,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<<|", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Below_stbox_stbox ) @@ -680,7 +662,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&<|", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overbelow_stbox_stbox ) @@ -688,7 +670,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "|>>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Above_stbox_stbox ) @@ -697,7 +679,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "|&>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overabove_stbox_stbox ) @@ -706,7 +688,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<<#", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Before_stbox_stbox ) @@ -715,7 +697,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&<#", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overbefore_stbox_stbox ) @@ -724,7 +706,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "#>>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::After_stbox_stbox ) @@ -733,7 +715,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "#&>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overafter_stbox_stbox ) @@ -742,7 +724,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Back_stbox_stbox ) @@ -769,7 +751,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "/&>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Overback_stbox_stbox ) @@ -778,8 +760,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_union", - {STBOX(), STBOX()}, - STBOX(), + {stbox(), stbox()}, + stbox(), StboxFunctions::Union_stbox_stbox ) ); @@ -787,8 +769,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_intersection", - {STBOX(), STBOX()}, - STBOX(), + {stbox(), stbox()}, + stbox(), StboxFunctions::Intersection_stbox_stbox ) ); @@ -796,8 +778,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "+", - {STBOX(), STBOX()}, - STBOX(), + {stbox(), stbox()}, + stbox(), StboxFunctions::Union_stbox_stbox ) ); @@ -805,8 +787,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "*", - {STBOX(), STBOX()}, - STBOX(), + {stbox(), stbox()}, + stbox(), StboxFunctions::Intersection_stbox_stbox ) ); @@ -814,7 +796,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_cmp", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::INTEGER, StboxFunctions::Stbox_cmp ) @@ -822,7 +804,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_eq", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_eq ) @@ -830,7 +812,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_ne", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_ne ) @@ -838,7 +820,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_lt", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_lt ) @@ -846,7 +828,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_le", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_le ) @@ -854,7 +836,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_ge", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_ge ) @@ -862,7 +844,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox_gt", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_gt ) @@ -871,7 +853,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "=", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_eq ) @@ -879,7 +861,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<>", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_ne ) @@ -887,7 +869,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_lt ) @@ -895,7 +877,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<=", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_le ) @@ -903,7 +885,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">=", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_ge ) @@ -911,7 +893,7 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">", - {STBOX(), STBOX()}, + {stbox(), stbox()}, LogicalType::BOOLEAN, StboxFunctions::Stbox_gt ) @@ -921,8 +903,8 @@ void StboxType::RegisterScalarFunctions(ExtensionLoader &loader) { * Tile / box emitters and single-tile getters ****************************************************/ { - const auto B = STBOX(); - const auto P = TgeompointType::TGEOMPOINT(); + const auto B = stbox(); + const auto P = TgeompointType::tgeompoint(); const auto G = GeoTypes::GEOMETRY(); const auto D = LogicalType::DOUBLE; const auto I = LogicalType::INTERVAL; diff --git a/src/geo/stbox_functions.cpp b/src/geo/stbox_functions.cpp index b5398f02..b76f19e3 100644 --- a/src/geo/stbox_functions.cpp +++ b/src/geo/stbox_functions.cpp @@ -59,7 +59,7 @@ inline void Stbox_normalize_geodetic_srid(STBox *box) { } // namespace /* *************************************************** - * In/out functions: VARCHAR <-> STBOX + * In/out functions: VARCHAR <-> stbox ****************************************************/ inline void Stbox_in_common(Vector &source, Vector &result, idx_t count) { @@ -113,7 +113,7 @@ bool StboxFunctions::Stbox_out(Vector &source, Vector &result, idx_t count, Cast const uint8_t *data = reinterpret_cast(input_blob.GetData()); size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -142,7 +142,7 @@ bool StboxFunctions::Stbox_out(Vector &source, Vector &result, idx_t count, Cast } /* *************************************************** - * In/out functions: WKB/HexWKB <-> STBOX + * In/out functions: WKB/HexWKB <-> stbox ****************************************************/ void StboxFunctions::Stbox_from_wkb(DataChunk &args, ExpressionState &state, Vector &result) { @@ -225,7 +225,7 @@ void StboxFunctions::Stbox_as_text(DataChunk &args, ExpressionState &state, Vect const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -259,7 +259,7 @@ void StboxFunctions::Stbox_as_wkb(DataChunk &args, ExpressionState &state, Vecto const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -294,7 +294,7 @@ void StboxFunctions::Stbox_as_hexwkb(DataChunk &args, ExpressionState &state, Ve const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -379,7 +379,7 @@ void StboxFunctions::Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &sta size_t span_data_size = span_blob.GetSize(); if (span_data_size < sizeof(Span)) { free(gs); - throw InvalidInputException("Invalid TSTZSPAN data: insufficient size"); + throw InvalidInputException("Invalid tstzspan data: insufficient size"); } uint8_t *span_data_copy = (uint8_t*)malloc(span_data_size); if (!span_data_copy) { @@ -391,7 +391,7 @@ void StboxFunctions::Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &sta if (!span) { free(gs); free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } STBox *ret = geo_tstzspan_to_stbox(gs, span); @@ -426,7 +426,7 @@ void StboxFunctions::Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &sta } /* *************************************************** - * Conversion functions + cast functions: [TYPE] -> STBOX + * Conversion functions + cast functions: [TYPE] -> stbox ****************************************************/ void StboxFunctions::Geo_to_stbox_common(Vector &source, Vector &result, idx_t count) { @@ -477,7 +477,7 @@ bool StboxFunctions::Geo_to_stbox_cast(Vector &source, Vector &result, idx_t cou } /* *************************************************** - * Conversion functions + cast functions: STBOX -> [TYPE] + * Conversion functions + cast functions: stbox -> [TYPE] ****************************************************/ void StboxFunctions::Stbox_to_geo(DataChunk &args, ExpressionState &state, Vector &result) { @@ -487,7 +487,7 @@ bool StboxFunctions::Geo_to_stbox_cast(Vector &source, Vector &result, idx_t cou const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -615,7 +615,7 @@ static void Tstzspan_to_stbox_common(Vector &source, Vector &result, idx_t count const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(Span)) { - throw InvalidInputException("Invalid TSTZSPAN data: insufficient size"); + throw InvalidInputException("Invalid tstzspan data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -718,7 +718,7 @@ void StboxFunctions::Stbox_hasx(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -744,7 +744,7 @@ void StboxFunctions::Stbox_hasz(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -770,7 +770,7 @@ void StboxFunctions::Stbox_hast(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -793,7 +793,7 @@ void StboxFunctions::Stbox_isgeodetic(DataChunk &args, ExpressionState &state, V const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -819,7 +819,7 @@ void StboxFunctions::Stbox_xmin(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -850,7 +850,7 @@ void StboxFunctions::Stbox_xmax(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -882,7 +882,7 @@ void StboxFunctions::Stbox_ymin(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -913,7 +913,7 @@ void StboxFunctions::Stbox_ymax(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -944,7 +944,7 @@ void StboxFunctions::Stbox_zmin(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -975,7 +975,7 @@ void StboxFunctions::Stbox_zmax(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1006,7 +1006,7 @@ void StboxFunctions::Stbox_tmin(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1038,7 +1038,7 @@ void StboxFunctions::Stbox_tmax(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1070,7 +1070,7 @@ void StboxFunctions::Stbox_tmin_inc(DataChunk &args, ExpressionState &state, Vec const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1101,7 +1101,7 @@ void StboxFunctions::Stbox_tmax_inc(DataChunk &args, ExpressionState &state, Vec const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1132,7 +1132,7 @@ void StboxFunctions::Stbox_area(DataChunk &args, ExpressionState &state, Vector const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1170,7 +1170,7 @@ void StboxFunctions::Stbox_volume(DataChunk &args, ExpressionState &state, Vecto const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1204,7 +1204,7 @@ void StboxFunctions::Stbox_shift_time(DataChunk &args, ExpressionState &state, V const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1240,7 +1240,7 @@ void StboxFunctions::Stbox_scale_time(DataChunk &args, ExpressionState &state, V const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1276,7 +1276,7 @@ void StboxFunctions::Stbox_shift_scale_time(DataChunk &args, ExpressionState &st const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1312,7 +1312,7 @@ void StboxFunctions::Stbox_get_space(DataChunk &args, ExpressionState &state, Ve const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1346,7 +1346,7 @@ void StboxFunctions::Stbox_expand_time(DataChunk &args, ExpressionState &state, const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size != sizeof(STBox)) { - throw InvalidInputException("Invalid STBOX value size (MEOS ABI mismatch or corrupt value)"); + throw InvalidInputException("Invalid stbox value size (MEOS ABI mismatch or corrupt value)"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1382,7 +1382,7 @@ void StboxFunctions::Stbox_expand_space(DataChunk &args, ExpressionState &state, const uint8_t *data = reinterpret_cast(input_stbox.GetData()); size_t data_size = input_stbox.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); @@ -1430,7 +1430,7 @@ void StboxFunctions::Overlaps_stbox_stbox(DataChunk &args, ExpressionState &stat const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1447,7 +1447,7 @@ void StboxFunctions::Overlaps_stbox_stbox(DataChunk &args, ExpressionState &stat size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1480,7 +1480,7 @@ void StboxFunctions::Contains_stbox_stbox(DataChunk &args, ExpressionState &stat const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1497,7 +1497,7 @@ void StboxFunctions::Contains_stbox_stbox(DataChunk &args, ExpressionState &stat size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1530,7 +1530,7 @@ void StboxFunctions::Contained_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1547,7 +1547,7 @@ void StboxFunctions::Contained_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1580,7 +1580,7 @@ void StboxFunctions::Same_stbox_stbox(DataChunk &args, ExpressionState &state, V const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1597,7 +1597,7 @@ void StboxFunctions::Same_stbox_stbox(DataChunk &args, ExpressionState &state, V size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1630,7 +1630,7 @@ void StboxFunctions::Adjacent_stbox_stbox(DataChunk &args, ExpressionState &stat const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1647,7 +1647,7 @@ void StboxFunctions::Adjacent_stbox_stbox(DataChunk &args, ExpressionState &stat size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1680,7 +1680,7 @@ void StboxFunctions::Left_stbox_stbox(DataChunk &args, ExpressionState &state, V const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1697,7 +1697,7 @@ void StboxFunctions::Left_stbox_stbox(DataChunk &args, ExpressionState &state, V size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1730,7 +1730,7 @@ void StboxFunctions::Overleft_stbox_stbox(DataChunk &args, ExpressionState &stat const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1747,7 +1747,7 @@ void StboxFunctions::Overleft_stbox_stbox(DataChunk &args, ExpressionState &stat size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1780,7 +1780,7 @@ void StboxFunctions::Right_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1797,7 +1797,7 @@ void StboxFunctions::Right_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1830,7 +1830,7 @@ void StboxFunctions::Overright_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1847,7 +1847,7 @@ void StboxFunctions::Overright_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1880,7 +1880,7 @@ void StboxFunctions::Below_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1897,7 +1897,7 @@ void StboxFunctions::Below_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1930,7 +1930,7 @@ void StboxFunctions::Overbelow_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1947,7 +1947,7 @@ void StboxFunctions::Overbelow_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -1980,7 +1980,7 @@ void StboxFunctions::Above_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -1997,7 +1997,7 @@ void StboxFunctions::Above_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2030,7 +2030,7 @@ void StboxFunctions::Overabove_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2047,7 +2047,7 @@ void StboxFunctions::Overabove_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2080,7 +2080,7 @@ void StboxFunctions::Before_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2097,7 +2097,7 @@ void StboxFunctions::Before_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2130,7 +2130,7 @@ void StboxFunctions::Overbefore_stbox_stbox(DataChunk &args, ExpressionState &st const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2147,7 +2147,7 @@ void StboxFunctions::Overbefore_stbox_stbox(DataChunk &args, ExpressionState &st size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2180,7 +2180,7 @@ void StboxFunctions::After_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2197,7 +2197,7 @@ void StboxFunctions::After_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2230,7 +2230,7 @@ void StboxFunctions::Overafter_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2247,7 +2247,7 @@ void StboxFunctions::Overafter_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2280,7 +2280,7 @@ void StboxFunctions::Front_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2297,7 +2297,7 @@ void StboxFunctions::Front_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2330,7 +2330,7 @@ void StboxFunctions::Overfront_stbox_stbox(DataChunk &args, ExpressionState &sta const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2347,7 +2347,7 @@ void StboxFunctions::Overfront_stbox_stbox(DataChunk &args, ExpressionState &sta size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2380,7 +2380,7 @@ void StboxFunctions::Back_stbox_stbox(DataChunk &args, ExpressionState &state, V const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2397,7 +2397,7 @@ void StboxFunctions::Back_stbox_stbox(DataChunk &args, ExpressionState &state, V size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2430,7 +2430,7 @@ void StboxFunctions::Overback_stbox_stbox(DataChunk &args, ExpressionState &stat const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2447,7 +2447,7 @@ void StboxFunctions::Overback_stbox_stbox(DataChunk &args, ExpressionState &stat size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2480,7 +2480,7 @@ void StboxFunctions::Union_stbox_stbox(DataChunk &args, ExpressionState &state, const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2497,7 +2497,7 @@ void StboxFunctions::Union_stbox_stbox(DataChunk &args, ExpressionState &state, size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { @@ -2548,7 +2548,7 @@ void StboxFunctions::Intersection_stbox_stbox(DataChunk &args, ExpressionState & const uint8_t *data1 = reinterpret_cast(input_stbox1.GetData()); size_t data_size1 = input_stbox1.GetSize(); if (data_size1 < sizeof(void*)) { - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy1 = (uint8_t*)malloc(data_size1); if (!data_copy1) { @@ -2565,7 +2565,7 @@ void StboxFunctions::Intersection_stbox_stbox(DataChunk &args, ExpressionState & size_t data_size2 = input_stbox2.GetSize(); if (data_size2 < sizeof(void*)) { free(data_copy1); - throw InvalidInputException("Invalid STBOX data: insufficient size"); + throw InvalidInputException("Invalid stbox data: insufficient size"); } uint8_t *data_copy2 = (uint8_t*)malloc(data_size2); if (!data_copy2) { diff --git a/src/geo/tgeogpoint.cpp b/src/geo/tgeogpoint.cpp index 3e205f66..a9ee4d38 100644 --- a/src/geo/tgeogpoint.cpp +++ b/src/geo/tgeogpoint.cpp @@ -32,38 +32,38 @@ extern "C" { namespace duckdb { -LogicalType TgeogpointType::TGEOGPOINT() { +LogicalType TgeogpointType::tgeogpoint() { LogicalType type(LogicalTypeId::BLOB); - type.SetAlias("TGEOGPOINT"); + type.SetAlias("tgeogpoint"); return type; } void TgeogpointType::RegisterType(ExtensionLoader &loader) { - loader.RegisterType("TGEOGPOINT", TGEOGPOINT()); + loader.RegisterType("tgeogpoint", tgeogpoint()); } void TgeogpointType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, - TGEOGPOINT(), + tgeogpoint(), TgeogpointFunctions::Tpoint_in ); - loader.RegisterCastFunction( - TGEOGPOINT(), + RegisterMeosCastFunction(loader, + tgeogpoint(), LogicalType::VARCHAR, TemporalFunctions::Temporal_out ); - loader.RegisterCastFunction( - TGEOGPOINT(), - StboxType::STBOX(), + RegisterMeosCastFunction(loader, + tgeogpoint(), + StboxType::stbox(), TgeompointFunctions::Tspatial_to_stbox_cast ); - loader.RegisterCastFunction( - TGEOGPOINT(), - SpanTypes::TSTZSPAN(), + RegisterMeosCastFunction(loader, + tgeogpoint(), + SpanTypes::tstzspan(), TgeompointFunctions::Temporal_to_tstzspan_cast ); } @@ -77,7 +77,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::VARCHAR, TgeompointFunctions::Tspatial_as_text ) @@ -86,7 +86,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::VARCHAR, TgeompointFunctions::Tspatial_as_ewkt ) @@ -97,7 +97,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {LogicalType::LIST(TGEOGPOINT())}, + {LogicalType::LIST(tgeogpoint())}, varchar_list, TgeompointFunctions::Spatialarr_as_text ) @@ -105,7 +105,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {LogicalType::LIST(TGEOGPOINT()), LogicalType::INTEGER}, + {LogicalType::LIST(tgeogpoint()), LogicalType::INTEGER}, varchar_list, TgeompointFunctions::Spatialarr_as_text ) @@ -114,7 +114,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {LogicalType::LIST(TGEOGPOINT())}, + {LogicalType::LIST(tgeogpoint())}, varchar_list, TgeompointFunctions::Spatialarr_as_ewkt ) @@ -122,7 +122,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {LogicalType::LIST(TGEOGPOINT()), LogicalType::INTEGER}, + {LogicalType::LIST(tgeogpoint()), LogicalType::INTEGER}, varchar_list, TgeompointFunctions::Spatialarr_as_ewkt ) @@ -133,18 +133,18 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { ****************************************************/ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "TGEOGPOINT", + "tgeogpoint", {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + tgeogpoint(), TgeogpointFunctions::Tpointinst_constructor ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "TGEOGPOINT", + "tgeogpoint", {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ, LogicalType::INTEGER}, - TGEOGPOINT(), + tgeogpoint(), TgeogpointFunctions::Tpointinst_constructor ) ); @@ -153,7 +153,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeogpoint", {GeoTypes::GEOMETRY(), SetTypes::tstzset()}, - TGEOGPOINT(), + tgeogpoint(), TemporalFunctions::Tsequence_from_base_tstzset ) ); @@ -161,8 +161,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpoint", - {GeoTypes::GEOMETRY(), SpanTypes::TSTZSPAN()}, - TGEOGPOINT(), + {GeoTypes::GEOMETRY(), SpanTypes::tstzspan()}, + tgeogpoint(), TemporalFunctions::Tsequence_from_base_tstzspan ) ); @@ -170,8 +170,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpoint", - {GeoTypes::GEOMETRY(), SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, - TGEOGPOINT(), + {GeoTypes::GEOMETRY(), SpanTypes::tstzspan(), LogicalType::VARCHAR}, + tgeogpoint(), TemporalFunctions::Tsequence_from_base_tstzspan ) ); @@ -180,7 +180,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeogpoint", {GeoTypes::GEOMETRY(), SpansetTypes::tstzspanset()}, - TGEOGPOINT(), + tgeogpoint(), TemporalFunctions::Tsequenceset_from_base_tstzspanset ) ); @@ -189,7 +189,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeogpoint", {GeoTypes::GEOMETRY(), SpansetTypes::tstzspanset(), LogicalType::VARCHAR}, - TGEOGPOINT(), + tgeogpoint(), TemporalFunctions::Tsequenceset_from_base_tstzspanset ) ); @@ -197,8 +197,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeq", - {LogicalType::LIST(TGEOGPOINT())}, - TGEOGPOINT(), + {LogicalType::LIST(tgeogpoint())}, + tgeogpoint(), TgeompointFunctions::Tgeompoint_sequence_constructor ) ); @@ -206,8 +206,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeqSet", - {LogicalType::LIST(TGEOGPOINT())}, - TGEOGPOINT(), + {LogicalType::LIST(tgeogpoint())}, + tgeogpoint(), TemporalFunctions::Tsequenceset_constructor ) ); @@ -215,8 +215,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox", - {TGEOGPOINT()}, - StboxType::STBOX(), + {tgeogpoint()}, + StboxType::stbox(), TgeompointFunctions::Tspatial_to_stbox ) ); @@ -224,14 +224,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { /* *************************************************** * Conversion functions ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timeSpan", - {TGEOGPOINT()}, - SpanTypes::TSTZSPAN(), - TgeompointFunctions::Temporal_to_tstzspan - ) - ); + // timeSpan(tgeogpoint) (temporal_to_tstzspan, group meos_temporal_conversion) is + // generated from the catalog in generated_temporal_udfs.cpp (RETIRED_GROUPS). /*************************************************** * Transformation functions @@ -240,8 +234,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointInst", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_to_tinstant ) ); @@ -249,8 +243,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeq", - {TGEOGPOINT(), LogicalType::VARCHAR}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::VARCHAR}, + tgeogpoint(), TemporalFunctions::Temporal_to_tsequence ) ); @@ -258,8 +252,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeq", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_to_tsequence ) ); @@ -267,8 +261,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeqSet", - {TGEOGPOINT(), LogicalType::VARCHAR}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::VARCHAR}, + tgeogpoint(), TemporalFunctions::Temporal_to_tsequenceset ) ); @@ -276,8 +270,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeogpointSeqSet", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_to_tsequenceset ) ); @@ -285,8 +279,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "setInterp", - {TGEOGPOINT(), LogicalType::VARCHAR}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::VARCHAR}, + tgeogpoint(), TemporalFunctions::Temporal_set_interp ) ); @@ -294,8 +288,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "appendInstant", - {TGEOGPOINT(), TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_append_tinstant ) ); @@ -303,8 +297,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "appendSequence", - {TGEOGPOINT(), TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_append_tsequence ) ); @@ -312,8 +306,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "merge", - {TGEOGPOINT(), TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_merge ) ); @@ -321,8 +315,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "merge", - {LogicalType::LIST(TGEOGPOINT())}, - TGEOGPOINT(), + {LogicalType::LIST(tgeogpoint())}, + tgeogpoint(), TemporalFunctions::Temporal_merge_array ) ); @@ -333,7 +327,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tempSubtype", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::VARCHAR, TemporalFunctions::Temporal_subtype ) @@ -342,7 +336,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "interp", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::VARCHAR, TemporalFunctions::Temporal_interp ) @@ -351,7 +345,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getValue", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_value ) @@ -360,7 +354,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getTimestamp", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Tinstant_timestamptz ) @@ -369,7 +363,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueSet", - {TGEOGPOINT()}, + {tgeogpoint()}, SpatialSetType::geomset(), TemporalFunctions::Temporal_valueset ) @@ -378,7 +372,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueN", - {TGEOGPOINT(), LogicalType::BIGINT}, + {tgeogpoint(), LogicalType::BIGINT}, GeoTypes::GEOMETRY(), TemporalFunctions::Temporal_value_n ) @@ -387,7 +381,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getTime", - {TGEOGPOINT()}, + {tgeogpoint()}, SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_time ) @@ -396,7 +390,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startValue", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_start_value ) @@ -405,7 +399,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endValue", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_end_value ) @@ -414,7 +408,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "duration", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::INTERVAL, TemporalFunctions::Temporal_duration ) @@ -423,7 +417,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "duration", - {TGEOGPOINT(), LogicalType::BOOLEAN}, + {tgeogpoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, TemporalFunctions::Temporal_duration ) @@ -432,7 +426,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "memSize", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_mem_size ) @@ -441,7 +435,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "lowerInc", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lower_inc ) @@ -450,7 +444,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "upperInc", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_upper_inc ) @@ -459,7 +453,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numInstants", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_instants ) @@ -468,8 +462,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startInstant", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_start_instant ) ); @@ -477,8 +471,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endInstant", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_end_instant ) ); @@ -486,8 +480,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "instantN", - {TGEOGPOINT(), LogicalType::INTEGER}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTEGER}, + tgeogpoint(), TemporalFunctions::Temporal_instant_n ) ); @@ -495,8 +489,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "instants", - {TGEOGPOINT()}, - LogicalType::LIST(TGEOGPOINT()), + {tgeogpoint()}, + LogicalType::LIST(tgeogpoint()), TemporalFunctions::Temporal_instants ) ); @@ -504,7 +498,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numTimestamps", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_timestamps ) @@ -513,7 +507,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startTimestamp", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_start_timestamptz ) @@ -522,7 +516,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endTimestamp", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_end_timestamptz ) @@ -531,25 +525,18 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "timestampN", - {TGEOGPOINT(), LogicalType::INTEGER}, + {tgeogpoint(), LogicalType::INTEGER}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_timestamptz_n ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timestamps", - {TGEOGPOINT()}, - LogicalType::LIST(LogicalType::TIMESTAMP_TZ), - TemporalFunctions::Temporal_timestamps - ) - ); + // timestamps(tgeogpoint) is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numSequences", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_sequences ) @@ -558,8 +545,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startSequence", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_start_sequence ) ); @@ -567,8 +554,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endSequence", - {TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_end_sequence ) ); @@ -576,8 +563,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "sequenceN", - {TGEOGPOINT(), LogicalType::INTEGER}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTEGER}, + tgeogpoint(), TemporalFunctions::Temporal_sequence_n ) ); @@ -585,8 +572,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "sequences", - {TGEOGPOINT()}, - LogicalType::LIST(TGEOGPOINT()), + {tgeogpoint()}, + LogicalType::LIST(tgeogpoint()), TemporalFunctions::Temporal_sequences ) ); @@ -594,8 +581,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "segments", - {TGEOGPOINT()}, - LogicalType::LIST(TGEOGPOINT()), + {tgeogpoint()}, + LogicalType::LIST(tgeogpoint()), TemporalFunctions::Temporal_segments ) ); @@ -606,8 +593,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftTime", - {TGEOGPOINT(), LogicalType::INTERVAL}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTERVAL}, + tgeogpoint(), TemporalFunctions::Temporal_shift_time ) ); @@ -615,8 +602,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleTime", - {TGEOGPOINT(), LogicalType::INTERVAL}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTERVAL}, + tgeogpoint(), TemporalFunctions::Temporal_scale_time ) ); @@ -624,8 +611,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleTime", - {TGEOGPOINT(), LogicalType::INTERVAL, LogicalType::INTERVAL}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTERVAL, LogicalType::INTERVAL}, + tgeogpoint(), TemporalFunctions::Temporal_shift_scale_time ) ); @@ -637,8 +624,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TGEOGPOINT(), + {tgeogpoint(), GeoTypes::GEOMETRY()}, + tgeogpoint(), TgeompointFunctions::Tgeompoint_at_value ) ); @@ -646,8 +633,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TGEOGPOINT(), + {tgeogpoint(), GeoTypes::GEOMETRY()}, + tgeogpoint(), TemporalFunctions::Temporal_minus_value ) ); @@ -655,8 +642,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TGEOGPOINT(), SpatialSetType::geomset()}, - TGEOGPOINT(), + {tgeogpoint(), SpatialSetType::geomset()}, + tgeogpoint(), TemporalFunctions::Temporal_at_values ) ); @@ -664,8 +651,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TGEOGPOINT(), SpatialSetType::geomset()}, - TGEOGPOINT(), + {tgeogpoint(), SpatialSetType::geomset()}, + tgeogpoint(), TemporalFunctions::Temporal_minus_value ) ); @@ -673,8 +660,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, + tgeogpoint(), TemporalFunctions::Temporal_at_timestamptz ) ); @@ -682,8 +669,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, + tgeogpoint(), TemporalFunctions::Temporal_minus_timestamptz ) ); @@ -691,7 +678,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueAtTimestamp", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, GeoTypes::GEOMETRY(), TemporalFunctions::Temporal_value_at_timestamptz ) @@ -700,8 +687,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOGPOINT(), SetTypes::tstzset()}, - TGEOGPOINT(), + {tgeogpoint(), SetTypes::tstzset()}, + tgeogpoint(), TemporalFunctions::Temporal_at_tstzset ) ); @@ -709,8 +696,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOGPOINT(), SetTypes::tstzset()}, - TGEOGPOINT(), + {tgeogpoint(), SetTypes::tstzset()}, + tgeogpoint(), TemporalFunctions::Temporal_minus_tstzset ) ); @@ -718,8 +705,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOGPOINT(), SpanTypes::TSTZSPAN()}, - TGEOGPOINT(), + {tgeogpoint(), SpanTypes::tstzspan()}, + tgeogpoint(), TemporalFunctions::Temporal_at_tstzspan ) ); @@ -727,8 +714,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOGPOINT(), SpanTypes::TSTZSPAN()}, - TGEOGPOINT(), + {tgeogpoint(), SpanTypes::tstzspan()}, + tgeogpoint(), TemporalFunctions::Temporal_minus_tstzspan ) ); @@ -736,8 +723,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOGPOINT(), SpansetTypes::tstzspanset()}, - TGEOGPOINT(), + {tgeogpoint(), SpansetTypes::tstzspanset()}, + tgeogpoint(), TemporalFunctions::Temporal_at_tstzspanset ) ); @@ -745,8 +732,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOGPOINT(), SpansetTypes::tstzspanset()}, - TGEOGPOINT(), + {tgeogpoint(), SpansetTypes::tstzspanset()}, + tgeogpoint(), TemporalFunctions::Temporal_minus_tstzspanset ) ); @@ -754,8 +741,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "beforeTimestamp", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, + tgeogpoint(), TemporalFunctions::Temporal_before_timestamptz ) ); @@ -763,8 +750,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "afterTimestamp", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, + tgeogpoint(), TemporalFunctions::Temporal_after_timestamptz ) ); @@ -775,8 +762,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "insert", - {TGEOGPOINT(), TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_update ) ); @@ -784,8 +771,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "insert", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint(), LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_update ) ); @@ -793,8 +780,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "update", - {TGEOGPOINT(), TGEOGPOINT()}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint()}, + tgeogpoint(), TemporalFunctions::Temporal_update ) ); @@ -802,8 +789,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "update", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), tgeogpoint(), LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_update ) ); @@ -811,8 +798,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ}, + tgeogpoint(), TemporalFunctions::Temporal_delete_timestamptz ) ); @@ -820,8 +807,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_delete_timestamptz ) ); @@ -829,8 +816,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SetTypes::tstzset()}, - TGEOGPOINT(), + {tgeogpoint(), SetTypes::tstzset()}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzset ) ); @@ -838,8 +825,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SetTypes::tstzset(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), SetTypes::tstzset(), LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzset ) ); @@ -847,8 +834,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SpanTypes::TSTZSPAN()}, - TGEOGPOINT(), + {tgeogpoint(), SpanTypes::tstzspan()}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzspan ) ); @@ -856,8 +843,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), SpanTypes::tstzspan(), LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzspan ) ); @@ -865,8 +852,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SpansetTypes::tstzspanset()}, - TGEOGPOINT(), + {tgeogpoint(), SpansetTypes::tstzspanset()}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzspanset ) ); @@ -874,8 +861,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOGPOINT(), SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, + tgeogpoint(), TemporalFunctions::Temporal_delete_tstzspanset ) ); @@ -887,8 +874,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stops", - {TGEOGPOINT(), LogicalType::DOUBLE, LogicalType::INTERVAL}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::DOUBLE, LogicalType::INTERVAL}, + tgeogpoint(), TgeompointFunctions::Tgeompoint_stops ) ); @@ -899,7 +886,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_eq", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_eq ) @@ -908,7 +895,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_ne", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ne ) @@ -917,7 +904,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_lt", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lt ) @@ -926,7 +913,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_le", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_le ) @@ -935,7 +922,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_gt", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_gt ) @@ -944,7 +931,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_ge", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ge ) @@ -953,7 +940,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_cmp", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_cmp ) @@ -962,7 +949,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "=", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_eq ) @@ -971,7 +958,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<>", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ne ) @@ -980,7 +967,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lt ) @@ -989,7 +976,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<=", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_le ) @@ -998,7 +985,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_gt ) @@ -1007,7 +994,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">=", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ge ) @@ -1019,8 +1006,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getX", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_x ) ); @@ -1028,8 +1015,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getY", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_y ) ); @@ -1037,8 +1024,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getZ", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_z ) ); @@ -1046,7 +1033,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "length", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::DOUBLE, TgeompointFunctions::Tpoint_length ) @@ -1055,8 +1042,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "cumulativeLength", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_cumulative_length ) ); @@ -1064,8 +1051,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "speed", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TemporalFunctions::Temporal_derivative ) ); @@ -1073,7 +1060,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "twCentroid", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_twcentroid ) @@ -1082,8 +1069,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "direction", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_direction ) ); @@ -1091,8 +1078,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "azimuth", - {TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_azimuth ) ); @@ -1100,7 +1087,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "angularDifference", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_angular_difference ) @@ -1109,7 +1096,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "isSimple", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::BOOLEAN, TgeompointFunctions::Tpoint_is_simple ) @@ -1118,8 +1105,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "makeSimple", - {TGEOGPOINT()}, - LogicalType::LIST(TGEOGPOINT()), + {tgeogpoint()}, + LogicalType::LIST(tgeogpoint()), TgeompointFunctions::Tpoint_make_simple ) ); @@ -1127,7 +1114,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "trajectory", - {TGEOGPOINT()}, + {tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_trajectory ) @@ -1136,7 +1123,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "trajectory_gs", - {TGEOGPOINT()}, + {tgeogpoint()}, LogicalType::BLOB, TgeompointFunctions::Tpoint_trajectory_gs ) @@ -1145,8 +1132,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atGeometry", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TGEOGPOINT(), + {tgeogpoint(), GeoTypes::GEOMETRY()}, + tgeogpoint(), TgeompointFunctions::Tgeo_at_geom ) ); @@ -1154,8 +1141,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusGeometry", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TGEOGPOINT(), + {tgeogpoint(), GeoTypes::GEOMETRY()}, + tgeogpoint(), TgeompointFunctions::Tgeo_minus_geom ) ); @@ -1163,8 +1150,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusGeometry", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), SpanTypes::FLOATSPAN()}, - TGEOGPOINT(), + {tgeogpoint(), GeoTypes::GEOMETRY(), SpanTypes::floatspan()}, + tgeogpoint(), TgeompointFunctions::Tgeo_minus_geom ) ); @@ -1172,8 +1159,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atStbox", - {TGEOGPOINT(), StboxType::STBOX()}, - TGEOGPOINT(), + {tgeogpoint(), StboxType::stbox()}, + tgeogpoint(), TgeompointFunctions::Tgeo_at_stbox ) ); @@ -1181,8 +1168,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atStbox", - {TGEOGPOINT(), StboxType::STBOX(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), StboxType::stbox(), LogicalType::BOOLEAN}, + tgeogpoint(), TgeompointFunctions::Tgeo_at_stbox ) ); @@ -1190,8 +1177,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusStbox", - {TGEOGPOINT(), StboxType::STBOX()}, - TGEOGPOINT(), + {tgeogpoint(), StboxType::stbox()}, + tgeogpoint(), TgeompointFunctions::Tgeo_minus_stbox ) ); @@ -1199,8 +1186,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusStbox", - {TGEOGPOINT(), StboxType::STBOX(), LogicalType::BOOLEAN}, - TGEOGPOINT(), + {tgeogpoint(), StboxType::stbox(), LogicalType::BOOLEAN}, + tgeogpoint(), TgeompointFunctions::Tgeo_minus_stbox ) ); @@ -1208,467 +1195,15 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "transform", - {TGEOGPOINT(), LogicalType::INTEGER}, - TGEOGPOINT(), + {tgeogpoint(), LogicalType::INTEGER}, + tgeogpoint(), TgeompointFunctions::Tspatial_transform ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TGEOGPOINT(), LogicalType::INTEGER}, - TGEOGPOINT(), - TemporalFunctions::Temporal_round - ) - ); + // round(tgeogpoint) at both arities is generated from the catalog temporal_round + // signature (generated_temporal_udfs.cpp); no hand registration remains. - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TGEOGPOINT()}, - TGEOGPOINT(), - TemporalFunctions::Temporal_round - ) - ); - - /* *************************************************** - * Spatial relationships - ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eContains", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Econtains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aContains", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Acontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {TGEOGPOINT(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {TGEOGPOINT(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {TGEOGPOINT(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {TGEOGPOINT(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eTouches", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Etouches_geo_tpoint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eTouches", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Etouches_tpoint_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aTouches", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Atouches_geo_tpoint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aTouches", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Atouches_tpoint_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_tgeo_tgeo - ) - ); - - /* *************************************************** - * Temporal-spatial relationships - ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tContains", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tcontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tContains", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tcontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOGPOINT(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOGPOINT(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {GeoTypes::GEOMETRY(), TGEOGPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {TGEOGPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {GeoTypes::GEOMETRY(), TGEOGPOINT(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOGPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOGPOINT(), TGEOGPOINT(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_tgeo - ) - ); /* *************************************************** * Operators (workaround as functions) @@ -1677,7 +1212,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", - {TGEOGPOINT(), StboxType::STBOX()}, + {tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_overlaps_tgeompoint_stbox ) @@ -1686,7 +1221,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", - {TGEOGPOINT(), SpanTypes::TSTZSPAN()}, + {tgeogpoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan ) @@ -1695,7 +1230,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "@>", - {TGEOGPOINT(), StboxType::STBOX()}, + {tgeogpoint(), StboxType::stbox()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_contains_tgeompoint_stbox ) @@ -1708,8 +1243,8 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<->", - {TGEOGPOINT(), TGEOGPOINT()}, - TemporalTypes::TFLOAT(), + {tgeogpoint(), tgeogpoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tdistance_tgeo_tgeo ) ); @@ -1717,7 +1252,7 @@ void TgeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shortestLine", - {TGEOGPOINT(), TGEOGPOINT()}, + {tgeogpoint(), tgeogpoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::ShortestLine_tgeo_tgeo ) @@ -1875,7 +1410,7 @@ void TgeogFromTextExec(DataChunk &args, ExpressionState &state, Vector &result) } // namespace void TgeogpointType::RegisterRoundtripIO(ExtensionLoader &loader) { - const auto T = TGEOGPOINT(); + const auto T = tgeogpoint(); const auto V = LogicalType::VARCHAR; const auto B = LogicalType::BLOB; const auto BL = LogicalType::BOOLEAN; @@ -1887,9 +1422,8 @@ void TgeogpointType::RegisterRoundtripIO(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKB", {T}, B, [](DataChunk &a, ExpressionState &s, Vector &r) { TgeogAsWkbExec(a, s, r, WKB_EXTENDED); })); - /* asHexWKB / asHexEWKB */ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {T}, V, - [](DataChunk &a, ExpressionState &s, Vector &r) { TgeogAsHexWkbExec(a, s, r, GEOG_WKB_BASE); })); + /* asHexEWKB (extended hex-WKB, includes SRID). asHexWKB (base) is generated from the + * catalog as the inherited Temporal output surface (generated_temporal_udfs.cpp). */ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexEWKB", {T}, V, [](DataChunk &a, ExpressionState &s, Vector &r) { TgeogAsHexWkbExec(a, s, r, WKB_EXTENDED); })); @@ -1920,9 +1454,9 @@ void TgeogpointType::RegisterRoundtripIO(ExtensionLoader &loader) { // TGeogpointType (new full-parity surface) // ============================================================ -LogicalType TGeogpointType::TGEOGPOINT() { +LogicalType TGeogpointType::tgeogpoint() { auto type = LogicalType(LogicalTypeId::BLOB); - type.SetAlias("TGEOGPOINT"); + type.SetAlias("tgeogpoint"); return type; } @@ -1941,7 +1475,7 @@ inline void Tgeogpoint_constructor(DataChunk &args, ExpressionState &state, Vect Temporal *tinst = tgeogpoint_in(input.c_str()); if (!tinst) { - throw InvalidInputException("Invalid TGEOGPOINT input: " + input); + throw InvalidInputException("Invalid tgeogpoint input: " + input); } size_t data_size = temporal_mem_size(tinst); @@ -1949,7 +1483,7 @@ inline void Tgeogpoint_constructor(DataChunk &args, ExpressionState &state, Vect uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(tinst); - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT data"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint data"); } memcpy(data_buffer, tinst, data_size); @@ -2314,13 +1848,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } Span *timespan = temporal_to_tstzspan(temp); if (!timespan) { - throw InvalidInputException("Failed to extract timespan from TGEOGPOINT"); + throw InvalidInputException("Failed to extract timespan from tgeogpoint"); } size_t span_size = sizeof(Span); @@ -2364,12 +1898,12 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } TInstant *inst = temporal_to_tinstant(temp); if (!inst) { - throw InvalidInputException("Failed to convert TGEOGPOINT to TInstant"); + throw InvalidInputException("Failed to convert tgeogpoint to TInstant"); } size_t inst_size = temporal_mem_size((Temporal*)inst); @@ -2414,7 +1948,7 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } std::string interp_str = interp_str_t.GetString(); @@ -2464,14 +1998,14 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); if (!temp1) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } std::string tgeom2 = tgeom2_str_t.GetString(); Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); if (!temp2) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } Temporal *result_temp = temporal_merge(temp1, temp2); @@ -2520,7 +2054,7 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } const char *subtype_str = temporal_subtype(temp); @@ -2556,7 +2090,7 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } @@ -2589,7 +2123,7 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } size_t mem_size = temporal_mem_size(temp); @@ -2880,12 +2414,12 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeogpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint deserialization"); } memcpy(data_copy, data, data_size); @@ -2893,7 +2427,7 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } TimestampTz meos_t = temp->t; @@ -2933,19 +2467,19 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector size_t data_size = tgeom_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeogpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } std::string interp_string = interp_str.GetString(); @@ -2992,87 +2526,82 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeogpoint_function = ScalarFunction( - "TGEOGPOINT", + "tgeogpoint", {LogicalType::VARCHAR}, - TGeogpointType::TGEOGPOINT(), + TGeogpointType::tgeogpoint(), Tgeogpoint_constructor ); loader.RegisterFunction( tgeogpoint_function); auto tgeogpoint_from_timestamp_function = ScalarFunction( - "TGEOGPOINT", + "tgeogpoint", {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, - TGeogpointType::TGEOGPOINT(), + TGeogpointType::tgeogpoint(), Tgeogpointinst_constructor); loader.RegisterFunction( tgeogpoint_from_timestamp_function); auto tgeogpoint_from_tstzspan_function = ScalarFunction( - "TGEOGPOINT", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, - TGeogpointType::TGEOGPOINT(), + "tgeogpoint", + {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_from_tstzspan ); loader.RegisterFunction( tgeogpoint_from_tstzspan_function); auto tgeogpoint_from_tstzspan_default = ScalarFunction( - "TGEOGPOINT", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, - TGeogpointType::TGEOGPOINT(), + "tgeogpoint", + {LogicalType::VARCHAR, SpanTypes::tstzspan()}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_from_tstzspan ); loader.RegisterFunction( tgeogpoint_from_tstzspan_default); auto tgeogpointseqarr_1param= ScalarFunction( "tgeogpointSeq", - {LogicalType::LIST(TGeogpointType::TGEOGPOINT())}, - TGeogpointType::TGEOGPOINT(), + {LogicalType::LIST(TGeogpointType::tgeogpoint())}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_constructor ); loader.RegisterFunction( tgeogpointseqarr_1param); auto tgeogpointseqarr_2params = ScalarFunction( "tgeogpointSeq", - {LogicalType::LIST(TGeogpointType::TGEOGPOINT()), LogicalType::VARCHAR}, - TGeogpointType::TGEOGPOINT(), + {LogicalType::LIST(TGeogpointType::tgeogpoint()), LogicalType::VARCHAR}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_constructor ); loader.RegisterFunction( tgeogpointseqarr_2params); auto tgeogpointseqarr_3params = ScalarFunction( "tgeogpointSeq", - {LogicalType::LIST(TGeogpointType::TGEOGPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - TGeogpointType::TGEOGPOINT(), + {LogicalType::LIST(TGeogpointType::tgeogpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_constructor ); loader.RegisterFunction( tgeogpointseqarr_3params); auto tgeogpointseqarr_4params = ScalarFunction( "tgeogpointSeq", - {LogicalType::LIST(TGeogpointType::TGEOGPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - TGeogpointType::TGEOGPOINT(), + {LogicalType::LIST(TGeogpointType::tgeogpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TGeogpointType::tgeogpoint(), Tgeogpoint_sequence_constructor ); loader.RegisterFunction( tgeogpointseqarr_4params); - auto tgeogpoint_to_timespan_function = ScalarFunction( - "timeSpan", - {TGeogpointType::TGEOGPOINT()}, - SpanTypes::TSTZSPAN(), - Temporal_to_tstzspan); - loader.RegisterFunction( tgeogpoint_to_timespan_function); + // timeSpan(tgeogpoint) is generated (meos_temporal_conversion, RETIRED_GROUPS). auto tgeogpoint_to_tinstant_function = ScalarFunction( "tgeogpointInst", - {TGeogpointType::TGEOGPOINT()}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint()}, + TGeogpointType::tgeogpoint(), Temporal_to_tinstant); loader.RegisterFunction( tgeogpoint_to_tinstant_function); auto setInterp_function = ScalarFunction( "setInterp", - {TGeogpointType::TGEOGPOINT(), LogicalType::VARCHAR}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint(), LogicalType::VARCHAR}, + TGeogpointType::tgeogpoint(), Temporal_set_interp ); loader.RegisterFunction( setInterp_function); @@ -3080,15 +2609,15 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto merge_function = ScalarFunction( "merge", - {TGeogpointType::TGEOGPOINT(), TGeogpointType::TGEOGPOINT()}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint(), TGeogpointType::tgeogpoint()}, + TGeogpointType::tgeogpoint(), Temporal_merge ); loader.RegisterFunction( merge_function); auto tempSubtype_function = ScalarFunction( "tempSubtype", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Temporal_subtype ); @@ -3096,7 +2625,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto interp_function = ScalarFunction( "interp", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Temporal_interp ); @@ -3104,7 +2633,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto memSize_function = ScalarFunction( "memSize", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::INTEGER, Temporal_mem_size ); @@ -3112,7 +2641,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto getValue_function = ScalarFunction( "getValue", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, GeoTypes::GEOMETRY(), Tinstant_value ); @@ -3121,7 +2650,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeogpoint_start_value_function = ScalarFunction( "startValue", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, GeoTypes::GEOMETRY(), Temporal_start_value ); @@ -3129,7 +2658,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeogpoint_end_value_function = ScalarFunction( "endValue", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, GeoTypes::GEOMETRY(), Temporal_end_value ); @@ -3137,24 +2666,24 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto startInstant_function = ScalarFunction( "startInstant", - {TGeogpointType::TGEOGPOINT()}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint()}, + TGeogpointType::tgeogpoint(), Temporal_start_instant ); loader.RegisterFunction( startInstant_function); auto endInstant_function = ScalarFunction( "endInstant", - {TGeogpointType::TGEOGPOINT()}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint()}, + TGeogpointType::tgeogpoint(), Temporal_end_instant ); loader.RegisterFunction( endInstant_function); auto instantN_function = ScalarFunction( "instantN", - {TGeogpointType::TGEOGPOINT(), LogicalType::INTEGER}, - TGeogpointType::TGEOGPOINT(), + {TGeogpointType::tgeogpoint(), LogicalType::INTEGER}, + TGeogpointType::tgeogpoint(), Temporal_instant_n ); loader.RegisterFunction( instantN_function); @@ -3162,7 +2691,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeogpoint_gettimestamptz_function = ScalarFunction( "getTimestamp", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::TIMESTAMP_TZ, Tinstant_timestamptz); loader.RegisterFunction( tgeogpoint_gettimestamptz_function); @@ -3174,7 +2703,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { // generic handlers wired for tgeompoint in temporal_functions.cpp. // =================================================================== - const LogicalType TGEOM = TGeogpointType::TGEOGPOINT(); + const LogicalType TGEOM = TGeogpointType::tgeogpoint(); const LogicalType GEOM = GeoTypes::GEOMETRY(); const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; const LogicalType IVAL = LogicalType::INTERVAL; @@ -3229,9 +2758,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "numTimestamps", {TGEOM}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_timestamps)); - loader.RegisterFunction(ScalarFunction( - "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), - TemporalFunctions::Temporal_timestamps)); + // timestamps(tgeogpoint) is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. loader.RegisterFunction(ScalarFunction( "startTimestamp", {TGEOM}, TSTZ, TemporalFunctions::Temporal_start_timestamptz)); @@ -3249,7 +2776,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_at_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "atTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -3257,7 +2784,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_minus_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "minusTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -3299,7 +2826,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { "minusGeometry", {TGEOM, GEOM}, TGEOM, TgeompointFunctions::Tgeo_minus_geom)); loader.RegisterFunction(ScalarFunction( - "minusStbox", {TGEOM, StboxType::STBOX()}, TGEOM, + "minusStbox", {TGEOM, StboxType::stbox()}, TGEOM, TgeompointFunctions::Tgeo_minus_stbox)); // ---- Modifiers (shift / scale / shiftScale / append / insert / update / @@ -3344,10 +2871,10 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzset)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan()}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, @@ -3393,7 +2920,7 @@ void TGeogpointType::RegisterScalarFunctions(ExtensionLoader &loader) { } void TGeogpointType::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TGEOGPOINT", TGeogpointType::TGEOGPOINT()); + loader.RegisterType( "tgeogpoint", TGeogpointType::tgeogpoint()); } diff --git a/src/geo/tgeogpoint_functions.cpp b/src/geo/tgeogpoint_functions.cpp index 87ecac96..4c3b0595 100644 --- a/src/geo/tgeogpoint_functions.cpp +++ b/src/geo/tgeogpoint_functions.cpp @@ -24,14 +24,14 @@ bool TgeogpointFunctions::Tpoint_in(Vector &source, Vector &result, idx_t count, Temporal *temp = tgeogpoint_in(input_str.c_str()); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT input: " + input_str); + throw InvalidInputException("Invalid tgeogpoint input: " + input_str); } size_t data_size = temporal_mem_size(temp); uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(temp); - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint"); } memcpy(data_buffer, temp, data_size); @@ -69,7 +69,7 @@ void TgeogpointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat Temporal *ret = (Temporal *) tpointinst_make(gs, static_cast(ts_meos.value)); if (ret == NULL) { free(gs); - throw InvalidInputException("Failed to create TGEOGPOINT from geometry and timestamp"); + throw InvalidInputException("Failed to create tgeogpoint from geometry and timestamp"); } size_t ret_size = temporal_mem_size(ret); @@ -77,7 +77,7 @@ void TgeogpointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat if (!ret_data) { free(ret); free(gs); - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint"); } memcpy(ret_data, ret, ret_size); diff --git a/src/geo/tgeogpoint_in_out.cpp b/src/geo/tgeogpoint_in_out.cpp index 63645c33..371db347 100644 --- a/src/geo/tgeogpoint_in_out.cpp +++ b/src/geo/tgeogpoint_in_out.cpp @@ -1,3 +1,4 @@ +#include "mobilityduck/meos_exec_serial.hpp" #include "geo/tgeogpoint.hpp" #include "geo/tgeogpoint_functions.hpp" #include "duckdb/main/extension/extension_loader.hpp" @@ -26,12 +27,12 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeogpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint deserialization"); } memcpy(data_copy, data, data_size); @@ -39,14 +40,14 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } char *str = tspatial_as_text(temp, 0); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGPOINT to text"); + throw InvalidInputException("Failed to convert tgeogpoint to text"); } std::string result_str(str); @@ -76,12 +77,12 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeogpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint deserialization"); } memcpy(data_copy, data, data_size); @@ -89,14 +90,14 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } char *ewkt = tspatial_as_ewkt(temp, 0); if (!ewkt) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGPOINT to EWKT"); + throw InvalidInputException("Failed to convert tgeogpoint to EWKT"); } std::string result_str(ewkt); @@ -124,14 +125,14 @@ bool TgeogpointFunctions::StringToTgeogpoint(Vector &source, Vector &result, idx Temporal *temp = tgeogpoint_in(input_str.c_str()); if (!temp) { - throw InvalidInputException("Invalid TGEOGPOINT input: " + input_str); + throw InvalidInputException("Invalid tgeogpoint input: " + input_str); } size_t data_size = temporal_mem_size(temp); uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(temp); - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT data"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint data"); } memcpy(data_buffer, temp, data_size); @@ -159,25 +160,25 @@ bool TgeogpointFunctions::TgeogpointToString(Vector &source, Vector &result, idx size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeogpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeogpoint deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeogpoint data: null pointer"); } char *str = temporal_out(temp, 15); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGPOINT to string"); + throw InvalidInputException("Failed to convert tgeogpoint to string"); } std::string output(str); @@ -198,7 +199,7 @@ bool TgeogpointFunctions::TgeogpointToString(Vector &source, Vector &result, idx void TGeogpointType::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeogpointAsText = ScalarFunction( "asText", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Tspatial_as_text ); @@ -206,7 +207,7 @@ void TGeogpointType::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeogpointAsEWKT = ScalarFunction( "asEWKT", - {TGeogpointType::TGEOGPOINT()}, + {TGeogpointType::tgeogpoint()}, LogicalType::VARCHAR, Tspatial_as_ewkt ); @@ -215,8 +216,8 @@ void TGeogpointType::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TGeogpointType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TGeogpointType::TGEOGPOINT(), TgeogpointFunctions::StringToTgeogpoint); - loader.RegisterCastFunction( TGeogpointType::TGEOGPOINT(), LogicalType::VARCHAR, TgeogpointFunctions::TgeogpointToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TGeogpointType::tgeogpoint(), TgeogpointFunctions::StringToTgeogpoint); + RegisterMeosCastFunction(loader, TGeogpointType::tgeogpoint(), LogicalType::VARCHAR, TgeogpointFunctions::TgeogpointToString); } } diff --git a/src/geo/tgeogpoint_ops.cpp b/src/geo/tgeogpoint_ops.cpp index b127ac4d..9c1b0b5c 100644 --- a/src/geo/tgeogpoint_ops.cpp +++ b/src/geo/tgeogpoint_ops.cpp @@ -264,7 +264,7 @@ inline string_t TemporalToBlob(Vector &result, Temporal *t) { return out; } -template +template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -272,14 +272,14 @@ void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, false, false); + Temporal *r = FN(t, gs); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -287,21 +287,21 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, false, false); + Temporal *r = FN(gs, t); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, false, false); + Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -309,7 +309,7 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { } // tDwithin variants take an extra distance argument. -template +template void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -317,14 +317,14 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, dist, false, false); + Temporal *r = FN(t, gs, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -332,21 +332,21 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, dist, false, false); + Temporal *r = FN(gs, t, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, dist, false, false); + Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -531,238 +531,32 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { } // namespace void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { - const LogicalType TGEOM = TGeogpointType::TGEOGPOINT(); + const LogicalType TGEOM = TGeogpointType::tgeogpoint(); const LogicalType GEOM = GeoTypes::GEOMETRY(); - const LogicalType STBOX = StboxType::STBOX(); - const LogicalType TSTZSPAN = SpanTypes::TSTZSPAN(); + const LogicalType stbox = StboxType::stbox(); + const LogicalType tstzspan = SpanTypes::tstzspan(); const LogicalType BOOL = LogicalType::BOOLEAN; const LogicalType DBL = LogicalType::DOUBLE; - const LogicalType TFLOAT = TemporalTypes::TFLOAT(); - - // ----------------------------------------------------------------- - // Box predicates: temporal_(overlaps|contains|contained|same|adjacent) - // and the equivalent operators (&&, @>, <@, ~=, -|-). - // ----------------------------------------------------------------- - struct BoxOp { - const char *fn_name; - const char *op_name; - bool (*tspatial_stbox)(const Temporal *, const STBox *); - bool (*tspatial_tspatial)(const Temporal *, const Temporal *); - bool (*temporal_tstzspan)(const Temporal *, const Span *); - bool (*tstzspan_temporal)(const Span *, const Temporal *); - }; - const BoxOp box_ops[] = { - {"temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal}, - {"temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal}, - {"temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal}, - {"temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal}, - {"temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal}, - }; + const LogicalType tfloat = TemporalTypes::tfloat(); - // Build per-overload registrations through static dispatch on the - // function pointer values supplied above. We can't bind those to - // template parameters at runtime, so we register each predicate - // explicitly below using the macros. -#define BOX_REG(NAME, OP, F_TSPAT_STBOX, F_TSPAT_TSPAT, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - - BOX_REG("temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal); - BOX_REG("temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal); - BOX_REG("temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal); - BOX_REG("temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal); - BOX_REG("temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal); -#undef BOX_REG + // Time-axis position predicates on tgeogpoint × tstzspan (both directions; + // before/after/overbefore/overafter, backing fns before_temporal_tstzspan etc. + // @ingroup meos_temporal_bbox_pos) are generated from the catalog sqlSignatures + // in src/generated/generated_temporal_udfs.cpp. The stale-snake temporal_* + // aliases are dropped (bare names supersede them). - // ----------------------------------------------------------------- - // Position predicates (left / right / below / above / front / back / - // before / after and their over-* variants). Only tgeogpoint × stbox - // and tgeogpoint × tgeogpoint — there are no time-axis positions for - // a tstzspan input that aren't already covered by the time-domain - // predicates wired in `temporal.cpp` for arbitrary temporals. - // ----------------------------------------------------------------- -#define POS_REG(NAME, F_TSPAT_STBOX, F_TSPAT_TSPAT) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - } while (0) - - POS_REG("temporal_left", left_tspatial_stbox, left_tspatial_tspatial); - POS_REG("temporal_overleft", overleft_tspatial_stbox, overleft_tspatial_tspatial); - POS_REG("temporal_right", right_tspatial_stbox, right_tspatial_tspatial); - POS_REG("temporal_overright", overright_tspatial_stbox, overright_tspatial_tspatial); - POS_REG("temporal_below", below_tspatial_stbox, below_tspatial_tspatial); - POS_REG("temporal_overbelow", overbelow_tspatial_stbox, overbelow_tspatial_tspatial); - POS_REG("temporal_above", above_tspatial_stbox, above_tspatial_tspatial); - POS_REG("temporal_overabove", overabove_tspatial_stbox, overabove_tspatial_tspatial); - POS_REG("temporal_front", front_tspatial_stbox, front_tspatial_tspatial); - POS_REG("temporal_overfront", overfront_tspatial_stbox, overfront_tspatial_tspatial); - POS_REG("temporal_back", back_tspatial_stbox, back_tspatial_tspatial); - POS_REG("temporal_overback", overback_tspatial_stbox, overback_tspatial_tspatial); - POS_REG("temporal_before", before_tspatial_stbox, before_tspatial_tspatial); - POS_REG("temporal_overbefore", overbefore_tspatial_stbox, overbefore_tspatial_tspatial); - POS_REG("temporal_after", after_tspatial_stbox, after_tspatial_tspatial); - POS_REG("temporal_overafter", overafter_tspatial_stbox, overafter_tspatial_tspatial); -#undef POS_REG - - // Time-axis position predicates also accept a tstzspan operand on the - // non-tspatial side — these reuse the generic temporal_* MEOS exports - // rather than the tspatial_* ones since they don't touch the spatial - // axes. -#define TIME_POS_REG(NAME, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN}, BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM}, BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - TIME_POS_REG("temporal_before", before_temporal_tstzspan, before_tstzspan_temporal); - TIME_POS_REG("temporal_overbefore", overbefore_temporal_tstzspan, overbefore_tstzspan_temporal); - TIME_POS_REG("temporal_after", after_temporal_tstzspan, after_tstzspan_temporal); - TIME_POS_REG("temporal_overafter", overafter_temporal_tstzspan, overafter_tstzspan_temporal); -#undef TIME_POS_REG - - // ----------------------------------------------------------------- - // Spatial relationships — ever (e*) and always (a*) versions for - // contains / disjoint / intersects / touches / dwithin. - // ----------------------------------------------------------------- -#define EA_REG_2(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - GeoTgeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - // disjoint / intersects / touches don't have a (geo, tgeo) MEOS export - // because they are commutative — eDisjoint(g, t) is just eDisjoint(t, g). -#define EA_REG_2_COMMUT(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - - // contains is non-commutative — uses both directions. - EA_REG_2("eContains", econtains_tgeo_geo, econtains_geo_tgeo, econtains_tgeo_tgeo); - EA_REG_2("aContains", acontains_tgeo_geo, acontains_geo_tgeo, acontains_tgeo_tgeo); - - EA_REG_2_COMMUT("eDisjoint", edisjoint_tgeo_geo, edisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("aDisjoint", adisjoint_tgeo_geo, adisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("eIntersects", eintersects_tgeo_geo, eintersects_tgeo_tgeo); - EA_REG_2_COMMUT("aIntersects", aintersects_tgeo_geo, aintersects_tgeo_tgeo); - EA_REG_2_COMMUT("eTouches", etouches_tgeo_geo, etouches_tgeo_tgeo); - EA_REG_2_COMMUT("aTouches", atouches_tgeo_geo, atouches_tgeo_tgeo); -#undef EA_REG_2 -#undef EA_REG_2_COMMUT - - // dwithin is symmetric in its first two arguments; MEOS only exports - // the (Temporal *, GSERIALIZED *) flavour, so the (geo, tgeo, dist) - // SQL form reuses it with arguments swapped at the call site. -#define EA_DWITHIN_REG(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM, DBL}, BOOL, \ - GeoTgeoDistIntExec_FromTgeoGeo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM, DBL}, BOOL, \ - TgeoGeoDistIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM, DBL}, BOOL, \ - TgeoTgeoDistIntExec)); \ - } while (0) - EA_DWITHIN_REG("eDwithin", edwithin_tgeo_geo, edwithin_tgeo_tgeo); - EA_DWITHIN_REG("aDwithin", adwithin_tgeo_geo, adwithin_tgeo_tgeo); -#undef EA_DWITHIN_REG - - // ----------------------------------------------------------------- - // Temporal spatial relationships (`tContains`, `tDisjoint`, - // `tIntersects`, `tTouches`, `tDwithin`) — return a temporal - // boolean whose truth value tracks the relation over time. - // ----------------------------------------------------------------- -#define TREL_REG(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, TemporalTypes::TBOOL(), \ - GeoTgeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, TemporalTypes::TBOOL(), \ - TgeoGeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, TemporalTypes::TBOOL(), \ - TgeoTgeoTempExec)); \ - } while (0) - - TREL_REG("tContains", tcontains_tgeo_geo, tcontains_geo_tgeo, tcontains_tgeo_tgeo); - TREL_REG("tDisjoint", tdisjoint_tgeo_geo, tdisjoint_geo_tgeo, tdisjoint_tgeo_tgeo); - TREL_REG("tIntersects", tintersects_tgeo_geo, tintersects_geo_tgeo, tintersects_tgeo_tgeo); - TREL_REG("tTouches", ttouches_tgeo_geo, ttouches_geo_tgeo, ttouches_tgeo_tgeo); -#undef TREL_REG - - // tDwithin takes the extra distance argument. - loader.RegisterFunction(ScalarFunction("tDwithin", - {GEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - GeoTgeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, GEOM, DBL}, TemporalTypes::TBOOL(), - TgeoGeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - TgeoTgeoDistTempExec)); // ----------------------------------------------------------------- // Distance — `tdistance(...)` and `<->`. // ----------------------------------------------------------------- loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); // ----------------------------------------------------------------- // Spatial functions: SRID accessor / setter, projection / transform, @@ -781,14 +575,14 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { // tgeogpoint → stbox is a cast in the SQL surface; expose it as a // function for now to keep the implementation a single template. loader.RegisterFunction(ScalarFunction( - "stbox", {TGEOM}, STBOX, TspatialToStboxExec)); + "stbox", {TGEOM}, stbox, TspatialToStboxExec)); // tgeogpoint <-> tgeography coercion functions. loader.RegisterFunction(ScalarFunction( - "tgeography", {TGEOM}, TGeographyTypes::TGEOGRAPHY(), + "tgeography", {TGEOM}, TGeographyTypes::tgeography(), TgeogpointToTgeographyExec)); loader.RegisterFunction(ScalarFunction( - "tgeogpoint", {TGeographyTypes::TGEOGRAPHY()}, TGEOM, + "tgeogpoint", {TGeographyTypes::tgeography()}, TGEOM, TgeographyToTgeogpointExec)); // Centroid / convexHull / traversedArea — produce a non-temporal @@ -861,7 +655,7 @@ void TGeogpointOps::RegisterScalarFunctions(ExtensionLoader &loader) { } }; - LogicalType list_stbox = LogicalType::LIST(STBOX); + LogicalType list_stbox = LogicalType::LIST(stbox); loader.RegisterFunction(ScalarFunction( "spaceBoxes", {TGEOM, DBL, DBL, DBL}, list_stbox, space_boxes_exec)); diff --git a/src/geo/tgeography.cpp b/src/geo/tgeography.cpp index 64c064b0..e8df8f4c 100644 --- a/src/geo/tgeography.cpp +++ b/src/geo/tgeography.cpp @@ -24,9 +24,9 @@ extern "C" { namespace duckdb { -LogicalType TGeographyTypes::TGEOGRAPHY() { +LogicalType TGeographyTypes::tgeography() { auto type = LogicalType(LogicalTypeId::BLOB); - type.SetAlias("TGEOGRAPHY"); + type.SetAlias("tgeography"); return type; } @@ -45,7 +45,7 @@ inline void Tgeog_constructor(DataChunk &args, ExpressionState &state, Vector &r Temporal *tinst = tgeography_in(input.c_str()); if (!tinst) { - throw InvalidInputException("Invalid TGEOGRAPHY input: " + input); + throw InvalidInputException("Invalid tgeography input: " + input); } size_t data_size = temporal_mem_size(tinst); @@ -53,7 +53,7 @@ inline void Tgeog_constructor(DataChunk &args, ExpressionState &state, Vector &r uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(tinst); - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY data"); + throw InvalidInputException("Failed to allocate memory for tgeography data"); } memcpy(data_buffer, tinst, data_size); @@ -412,13 +412,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } Span *timespan = temporal_to_tstzspan(temp); if (!timespan) { - throw InvalidInputException("Failed to extract timespan from TGEOGRAPHY"); + throw InvalidInputException("Failed to extract timespan from tgeography"); } size_t span_size = sizeof(Span); @@ -462,12 +462,12 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } TInstant *inst = temporal_to_tinstant(temp); if (!inst) { - throw InvalidInputException("Failed to convert TGEOGRAPHY to TInstant"); + throw InvalidInputException("Failed to convert tgeography to TInstant"); } size_t inst_size = temporal_mem_size((Temporal*)inst); @@ -512,7 +512,7 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } std::string interp_str = interp_str_t.GetString(); @@ -562,14 +562,14 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); if (!temp1) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } std::string tgeom2 = tgeom2_str_t.GetString(); Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); if (!temp2) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } Temporal *result_temp = temporal_merge(temp1, temp2); @@ -618,7 +618,7 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } const char *subtype_str = temporal_subtype(temp); @@ -654,7 +654,7 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } @@ -687,7 +687,7 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } size_t mem_size = temporal_mem_size(temp); @@ -978,12 +978,12 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGRAPHY data: insufficient size"); + throw InvalidInputException("Invalid tgeography data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeography deserialization"); } memcpy(data_copy, data, data_size); @@ -991,7 +991,7 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } TimestampTz meos_t = temp->t; @@ -1031,19 +1031,19 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector size_t data_size = tgeom_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGRAPHY data: insufficient size"); + throw InvalidInputException("Invalid tgeography data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeography deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } std::string interp_string = interp_str.GetString(); @@ -1090,87 +1090,82 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeography_function = ScalarFunction( - "TGEOGRAPHY", + "tgeography", {LogicalType::VARCHAR}, - TGeographyTypes::TGEOGRAPHY(), + TGeographyTypes::tgeography(), Tgeog_constructor ); loader.RegisterFunction( tgeography_function); auto tgeography_from_timestamp_function = ScalarFunction( - "TGEOGRAPHY", + "tgeography", {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, - TGeographyTypes::TGEOGRAPHY(), + TGeographyTypes::tgeography(), Tgeoginst_constructor); loader.RegisterFunction( tgeography_from_timestamp_function); auto tgeography_from_tstzspan_function = ScalarFunction( - "TGEOGRAPHY", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, - TGeographyTypes::TGEOGRAPHY(), + "tgeography", + {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR}, + TGeographyTypes::tgeography(), Tgeography_sequence_from_tstzspan ); loader.RegisterFunction( tgeography_from_tstzspan_function); auto tgeography_from_tstzspan_default = ScalarFunction( - "TGEOGRAPHY", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, - TGeographyTypes::TGEOGRAPHY(), + "tgeography", + {LogicalType::VARCHAR, SpanTypes::tstzspan()}, + TGeographyTypes::tgeography(), Tgeography_sequence_from_tstzspan ); loader.RegisterFunction( tgeography_from_tstzspan_default); auto tgeographyseqarr_1param= ScalarFunction( "tgeographySeq", - {LogicalType::LIST(TGeographyTypes::TGEOGRAPHY())}, - TGeographyTypes::TGEOGRAPHY(), + {LogicalType::LIST(TGeographyTypes::tgeography())}, + TGeographyTypes::tgeography(), Tgeography_sequence_constructor ); loader.RegisterFunction( tgeographyseqarr_1param); auto tgeographyseqarr_2params = ScalarFunction( "tgeographySeq", - {LogicalType::LIST(TGeographyTypes::TGEOGRAPHY()), LogicalType::VARCHAR}, - TGeographyTypes::TGEOGRAPHY(), + {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::VARCHAR}, + TGeographyTypes::tgeography(), Tgeography_sequence_constructor ); loader.RegisterFunction( tgeographyseqarr_2params); auto tgeographyseqarr_3params = ScalarFunction( "tgeographySeq", - {LogicalType::LIST(TGeographyTypes::TGEOGRAPHY()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - TGeographyTypes::TGEOGRAPHY(), + {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TGeographyTypes::tgeography(), Tgeography_sequence_constructor ); loader.RegisterFunction( tgeographyseqarr_3params); auto tgeographyseqarr_4params = ScalarFunction( "tgeographySeq", - {LogicalType::LIST(TGeographyTypes::TGEOGRAPHY()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - TGeographyTypes::TGEOGRAPHY(), + {LogicalType::LIST(TGeographyTypes::tgeography()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TGeographyTypes::tgeography(), Tgeography_sequence_constructor ); loader.RegisterFunction( tgeographyseqarr_4params); - auto tgeography_to_timespan_function = ScalarFunction( - "timeSpan", - {TGeographyTypes::TGEOGRAPHY()}, - SpanTypes::TSTZSPAN(), - Temporal_to_tstzspan); - loader.RegisterFunction( tgeography_to_timespan_function); + // timeSpan(tgeography) is generated (meos_temporal_conversion, RETIRED_GROUPS). auto tgeography_to_tinstant_function = ScalarFunction( "tgeographyInst", - {TGeographyTypes::TGEOGRAPHY()}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography()}, + TGeographyTypes::tgeography(), Temporal_to_tinstant); loader.RegisterFunction( tgeography_to_tinstant_function); auto setInterp_function = ScalarFunction( "setInterp", - {TGeographyTypes::TGEOGRAPHY(), LogicalType::VARCHAR}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography(), LogicalType::VARCHAR}, + TGeographyTypes::tgeography(), Temporal_set_interp ); loader.RegisterFunction( setInterp_function); @@ -1178,15 +1173,15 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto merge_function = ScalarFunction( "merge", - {TGeographyTypes::TGEOGRAPHY(), TGeographyTypes::TGEOGRAPHY()}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography(), TGeographyTypes::tgeography()}, + TGeographyTypes::tgeography(), Temporal_merge ); loader.RegisterFunction( merge_function); auto tempSubtype_function = ScalarFunction( "tempSubtype", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Temporal_subtype ); @@ -1194,7 +1189,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto interp_function = ScalarFunction( "interp", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Temporal_interp ); @@ -1202,7 +1197,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto memSize_function = ScalarFunction( "memSize", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::INTEGER, Temporal_mem_size ); @@ -1210,7 +1205,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto getValue_function = ScalarFunction( "getValue", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, GeoTypes::GEOMETRY(), Tinstant_value ); @@ -1219,7 +1214,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeography_start_value_function = ScalarFunction( "startValue", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, GeoTypes::GEOMETRY(), Temporal_start_value ); @@ -1227,7 +1222,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeography_end_value_function = ScalarFunction( "endValue", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, GeoTypes::GEOMETRY(), Temporal_end_value ); @@ -1235,24 +1230,24 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto startInstant_function = ScalarFunction( "startInstant", - {TGeographyTypes::TGEOGRAPHY()}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography()}, + TGeographyTypes::tgeography(), Temporal_start_instant ); loader.RegisterFunction( startInstant_function); auto endInstant_function = ScalarFunction( "endInstant", - {TGeographyTypes::TGEOGRAPHY()}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography()}, + TGeographyTypes::tgeography(), Temporal_end_instant ); loader.RegisterFunction( endInstant_function); auto instantN_function = ScalarFunction( "instantN", - {TGeographyTypes::TGEOGRAPHY(), LogicalType::INTEGER}, - TGeographyTypes::TGEOGRAPHY(), + {TGeographyTypes::tgeography(), LogicalType::INTEGER}, + TGeographyTypes::tgeography(), Temporal_instant_n ); loader.RegisterFunction( instantN_function); @@ -1260,7 +1255,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeography_gettimestamptz_function = ScalarFunction( "getTimestamp", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::TIMESTAMP_TZ, Tinstant_timestamptz); loader.RegisterFunction( tgeography_gettimestamptz_function); @@ -1272,7 +1267,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // generic handlers wired for tgeompoint in temporal_functions.cpp. // =================================================================== - const LogicalType TGEOM = TGeographyTypes::TGEOGRAPHY(); + const LogicalType TGEOM = TGeographyTypes::tgeography(); const LogicalType GEOM = GeoTypes::GEOMETRY(); const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; const LogicalType IVAL = LogicalType::INTERVAL; @@ -1327,9 +1322,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "numTimestamps", {TGEOM}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_timestamps)); - loader.RegisterFunction(ScalarFunction( - "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), - TemporalFunctions::Temporal_timestamps)); + // timestamps(tgeography) is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. loader.RegisterFunction(ScalarFunction( "startTimestamp", {TGEOM}, TSTZ, TemporalFunctions::Temporal_start_timestamptz)); @@ -1347,7 +1340,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_at_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "atTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -1355,7 +1348,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_minus_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "minusTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -1397,7 +1390,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { "minusGeometry", {TGEOM, GEOM}, TGEOM, TgeompointFunctions::Tgeo_minus_geom)); loader.RegisterFunction(ScalarFunction( - "minusStbox", {TGEOM, StboxType::STBOX()}, TGEOM, + "minusStbox", {TGEOM, StboxType::stbox()}, TGEOM, TgeompointFunctions::Tgeo_minus_stbox)); // ---- Modifiers (shift / scale / shiftScale / append / insert / update / @@ -1442,10 +1435,10 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzset)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan()}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, @@ -1491,7 +1484,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } void TGeographyTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TGEOGRAPHY", TGeographyTypes::TGEOGRAPHY()); + loader.RegisterType( "tgeography", TGeographyTypes::tgeography()); } diff --git a/src/geo/tgeography_in_out.cpp b/src/geo/tgeography_in_out.cpp index 3d5fac17..046534d1 100644 --- a/src/geo/tgeography_in_out.cpp +++ b/src/geo/tgeography_in_out.cpp @@ -26,12 +26,12 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGRAPHY data: insufficient size"); + throw InvalidInputException("Invalid tgeography data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeography deserialization"); } memcpy(data_copy, data, data_size); @@ -39,14 +39,14 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } char *str = tspatial_as_text(temp, 0); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGRAPHY to text"); + throw InvalidInputException("Failed to convert tgeography to text"); } std::string result_str(str); @@ -76,12 +76,12 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGRAPHY data: insufficient size"); + throw InvalidInputException("Invalid tgeography data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeography deserialization"); } memcpy(data_copy, data, data_size); @@ -89,14 +89,14 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } char *ewkt = tspatial_as_ewkt(temp, 0); if (!ewkt) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGRAPHY to EWKT"); + throw InvalidInputException("Failed to convert tgeography to EWKT"); } std::string result_str(ewkt); @@ -124,14 +124,14 @@ bool TgeographyFunctions::StringToTgeography(Vector &source, Vector &result, idx Temporal *temp = tgeography_in(input_str.c_str()); if (!temp) { - throw InvalidInputException("Invalid TGEOGRAPHY input: " + input_str); + throw InvalidInputException("Invalid tgeography input: " + input_str); } size_t data_size = temporal_mem_size(temp); uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(temp); - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY data"); + throw InvalidInputException("Failed to allocate memory for tgeography data"); } memcpy(data_buffer, temp, data_size); @@ -159,25 +159,25 @@ bool TgeographyFunctions::TgeographyToString(Vector &source, Vector &result, idx size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOGRAPHY data: insufficient size"); + throw InvalidInputException("Invalid tgeography data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOGRAPHY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeography deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOGRAPHY data: null pointer"); + throw InvalidInputException("Invalid tgeography data: null pointer"); } char *str = temporal_out(temp, 15); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOGRAPHY to string"); + throw InvalidInputException("Failed to convert tgeography to string"); } std::string output(str); @@ -250,7 +250,7 @@ inline void TgeographyFromStringExec(DataChunk &args, ExpressionState &, Vector void TGeographyTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeographyAsText = ScalarFunction( "asText", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Tspatial_as_text ); @@ -258,7 +258,7 @@ void TGeographyTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeographyAsEWKT = ScalarFunction( "asEWKT", - {TGeographyTypes::TGEOGRAPHY()}, + {TGeographyTypes::tgeography()}, LogicalType::VARCHAR, Tspatial_as_ewkt ); @@ -266,7 +266,7 @@ void TGeographyTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ const auto B = LogicalType::BLOB; const auto V = LogicalType::VARCHAR; - const auto T = TGeographyTypes::TGEOGRAPHY(); + const auto T = TGeographyTypes::tgeography(); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tgeographyFromBinary", {B}, T, TgeographyFromWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, @@ -288,8 +288,8 @@ void TGeographyTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TGeographyTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TGeographyTypes::TGEOGRAPHY(), TgeographyFunctions::StringToTgeography); - loader.RegisterCastFunction( TGeographyTypes::TGEOGRAPHY(), LogicalType::VARCHAR, TgeographyFunctions::TgeographyToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TGeographyTypes::tgeography(), TgeographyFunctions::StringToTgeography); + RegisterMeosCastFunction(loader, TGeographyTypes::tgeography(), LogicalType::VARCHAR, TgeographyFunctions::TgeographyToString); } } diff --git a/src/geo/tgeography_ops.cpp b/src/geo/tgeography_ops.cpp index 58489281..893494c5 100644 --- a/src/geo/tgeography_ops.cpp +++ b/src/geo/tgeography_ops.cpp @@ -265,7 +265,7 @@ inline string_t TemporalToBlob(Vector &result, Temporal *t) { return out; } -template +template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -273,14 +273,14 @@ void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, false, false); + Temporal *r = FN(t, gs); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -288,21 +288,21 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, false, false); + Temporal *r = FN(gs, t); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, false, false); + Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -310,7 +310,7 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { } // tDwithin variants take an extra distance argument. -template +template void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -318,14 +318,14 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, dist, false, false); + Temporal *r = FN(t, gs, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -333,21 +333,21 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, dist, false, false); + Temporal *r = FN(gs, t, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, dist, false, false); + Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -533,238 +533,32 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { } // namespace void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { - const LogicalType TGEOM = TGeographyTypes::TGEOGRAPHY(); + const LogicalType TGEOM = TGeographyTypes::tgeography(); const LogicalType GEOM = GeoTypes::GEOMETRY(); - const LogicalType STBOX = StboxType::STBOX(); - const LogicalType TSTZSPAN = SpanTypes::TSTZSPAN(); + const LogicalType stbox = StboxType::stbox(); + const LogicalType tstzspan = SpanTypes::tstzspan(); const LogicalType BOOL = LogicalType::BOOLEAN; const LogicalType DBL = LogicalType::DOUBLE; - const LogicalType TFLOAT = TemporalTypes::TFLOAT(); - - // ----------------------------------------------------------------- - // Box predicates: temporal_(overlaps|contains|contained|same|adjacent) - // and the equivalent operators (&&, @>, <@, ~=, -|-). - // ----------------------------------------------------------------- - struct BoxOp { - const char *fn_name; - const char *op_name; - bool (*tspatial_stbox)(const Temporal *, const STBox *); - bool (*tspatial_tspatial)(const Temporal *, const Temporal *); - bool (*temporal_tstzspan)(const Temporal *, const Span *); - bool (*tstzspan_temporal)(const Span *, const Temporal *); - }; - const BoxOp box_ops[] = { - {"temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal}, - {"temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal}, - {"temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal}, - {"temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal}, - {"temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal}, - }; + const LogicalType tfloat = TemporalTypes::tfloat(); - // Build per-overload registrations through static dispatch on the - // function pointer values supplied above. We can't bind those to - // template parameters at runtime, so we register each predicate - // explicitly below using the macros. -#define BOX_REG(NAME, OP, F_TSPAT_STBOX, F_TSPAT_TSPAT, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - - BOX_REG("temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal); - BOX_REG("temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal); - BOX_REG("temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal); - BOX_REG("temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal); - BOX_REG("temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal); -#undef BOX_REG + // Time-axis position predicates on tgeography × tstzspan (both directions; + // before/after/overbefore/overafter, backing fns before_temporal_tstzspan etc. + // @ingroup meos_temporal_bbox_pos) are generated from the catalog sqlSignatures + // in src/generated/generated_temporal_udfs.cpp. The stale-snake temporal_* + // aliases are dropped (bare names supersede them). - // ----------------------------------------------------------------- - // Position predicates (left / right / below / above / front / back / - // before / after and their over-* variants). Only tgeography × stbox - // and tgeography × tgeography — there are no time-axis positions for - // a tstzspan input that aren't already covered by the time-domain - // predicates wired in `temporal.cpp` for arbitrary temporals. - // ----------------------------------------------------------------- -#define POS_REG(NAME, F_TSPAT_STBOX, F_TSPAT_TSPAT) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - } while (0) - - POS_REG("temporal_left", left_tspatial_stbox, left_tspatial_tspatial); - POS_REG("temporal_overleft", overleft_tspatial_stbox, overleft_tspatial_tspatial); - POS_REG("temporal_right", right_tspatial_stbox, right_tspatial_tspatial); - POS_REG("temporal_overright", overright_tspatial_stbox, overright_tspatial_tspatial); - POS_REG("temporal_below", below_tspatial_stbox, below_tspatial_tspatial); - POS_REG("temporal_overbelow", overbelow_tspatial_stbox, overbelow_tspatial_tspatial); - POS_REG("temporal_above", above_tspatial_stbox, above_tspatial_tspatial); - POS_REG("temporal_overabove", overabove_tspatial_stbox, overabove_tspatial_tspatial); - POS_REG("temporal_front", front_tspatial_stbox, front_tspatial_tspatial); - POS_REG("temporal_overfront", overfront_tspatial_stbox, overfront_tspatial_tspatial); - POS_REG("temporal_back", back_tspatial_stbox, back_tspatial_tspatial); - POS_REG("temporal_overback", overback_tspatial_stbox, overback_tspatial_tspatial); - POS_REG("temporal_before", before_tspatial_stbox, before_tspatial_tspatial); - POS_REG("temporal_overbefore", overbefore_tspatial_stbox, overbefore_tspatial_tspatial); - POS_REG("temporal_after", after_tspatial_stbox, after_tspatial_tspatial); - POS_REG("temporal_overafter", overafter_tspatial_stbox, overafter_tspatial_tspatial); -#undef POS_REG - - // Time-axis position predicates also accept a tstzspan operand on the - // non-tspatial side — these reuse the generic temporal_* MEOS exports - // rather than the tspatial_* ones since they don't touch the spatial - // axes. -#define TIME_POS_REG(NAME, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN}, BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM}, BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - TIME_POS_REG("temporal_before", before_temporal_tstzspan, before_tstzspan_temporal); - TIME_POS_REG("temporal_overbefore", overbefore_temporal_tstzspan, overbefore_tstzspan_temporal); - TIME_POS_REG("temporal_after", after_temporal_tstzspan, after_tstzspan_temporal); - TIME_POS_REG("temporal_overafter", overafter_temporal_tstzspan, overafter_tstzspan_temporal); -#undef TIME_POS_REG - - // ----------------------------------------------------------------- - // Spatial relationships — ever (e*) and always (a*) versions for - // contains / disjoint / intersects / touches / dwithin. - // ----------------------------------------------------------------- -#define EA_REG_2(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - GeoTgeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - // disjoint / intersects / touches don't have a (geo, tgeo) MEOS export - // because they are commutative — eDisjoint(g, t) is just eDisjoint(t, g). -#define EA_REG_2_COMMUT(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - - // contains is non-commutative — uses both directions. - EA_REG_2("eContains", econtains_tgeo_geo, econtains_geo_tgeo, econtains_tgeo_tgeo); - EA_REG_2("aContains", acontains_tgeo_geo, acontains_geo_tgeo, acontains_tgeo_tgeo); - - EA_REG_2_COMMUT("eDisjoint", edisjoint_tgeo_geo, edisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("aDisjoint", adisjoint_tgeo_geo, adisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("eIntersects", eintersects_tgeo_geo, eintersects_tgeo_tgeo); - EA_REG_2_COMMUT("aIntersects", aintersects_tgeo_geo, aintersects_tgeo_tgeo); - EA_REG_2_COMMUT("eTouches", etouches_tgeo_geo, etouches_tgeo_tgeo); - EA_REG_2_COMMUT("aTouches", atouches_tgeo_geo, atouches_tgeo_tgeo); -#undef EA_REG_2 -#undef EA_REG_2_COMMUT - - // dwithin is symmetric in its first two arguments; MEOS only exports - // the (Temporal *, GSERIALIZED *) flavour, so the (geo, tgeo, dist) - // SQL form reuses it with arguments swapped at the call site. -#define EA_DWITHIN_REG(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM, DBL}, BOOL, \ - GeoTgeoDistIntExec_FromTgeoGeo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM, DBL}, BOOL, \ - TgeoGeoDistIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM, DBL}, BOOL, \ - TgeoTgeoDistIntExec)); \ - } while (0) - EA_DWITHIN_REG("eDwithin", edwithin_tgeo_geo, edwithin_tgeo_tgeo); - EA_DWITHIN_REG("aDwithin", adwithin_tgeo_geo, adwithin_tgeo_tgeo); -#undef EA_DWITHIN_REG - - // ----------------------------------------------------------------- - // Temporal spatial relationships (`tContains`, `tDisjoint`, - // `tIntersects`, `tTouches`, `tDwithin`) — return a temporal - // boolean whose truth value tracks the relation over time. - // ----------------------------------------------------------------- -#define TREL_REG(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, TemporalTypes::TBOOL(), \ - GeoTgeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, TemporalTypes::TBOOL(), \ - TgeoGeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, TemporalTypes::TBOOL(), \ - TgeoTgeoTempExec)); \ - } while (0) - - TREL_REG("tContains", tcontains_tgeo_geo, tcontains_geo_tgeo, tcontains_tgeo_tgeo); - TREL_REG("tDisjoint", tdisjoint_tgeo_geo, tdisjoint_geo_tgeo, tdisjoint_tgeo_tgeo); - TREL_REG("tIntersects", tintersects_tgeo_geo, tintersects_geo_tgeo, tintersects_tgeo_tgeo); - TREL_REG("tTouches", ttouches_tgeo_geo, ttouches_geo_tgeo, ttouches_tgeo_tgeo); -#undef TREL_REG - - // tDwithin takes the extra distance argument. - loader.RegisterFunction(ScalarFunction("tDwithin", - {GEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - GeoTgeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, GEOM, DBL}, TemporalTypes::TBOOL(), - TgeoGeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - TgeoTgeoDistTempExec)); // ----------------------------------------------------------------- // Distance — `tdistance(...)` and `<->`. // ----------------------------------------------------------------- loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); // ----------------------------------------------------------------- // Spatial functions: SRID accessor / setter, projection / transform, @@ -783,15 +577,15 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { // tgeography → stbox is a cast in the SQL surface; expose it as a // function for now to keep the implementation a single template. loader.RegisterFunction(ScalarFunction( - "stbox", {TGEOM}, STBOX, TspatialToStboxExec)); + "stbox", {TGEOM}, stbox, TspatialToStboxExec)); // tgeography <-> tgeometry coercion functions. (tgeogpoint // coercions are deferred until tgeogpoint is registered.) loader.RegisterFunction(ScalarFunction( - "tgeometry", {TGEOM}, TGeometryTypes::TGEOMETRY(), + "tgeometry", {TGEOM}, TGeometryTypes::tgeometry(), TgeographyToTgeometryExec)); loader.RegisterFunction(ScalarFunction( - "tgeography", {TGeometryTypes::TGEOMETRY()}, TGEOM, + "tgeography", {TGeometryTypes::tgeometry()}, TGEOM, TgeometryToTgeographyExec)); // Centroid / convexHull / traversedArea — produce a non-temporal @@ -864,7 +658,7 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { } }; - LogicalType list_stbox = LogicalType::LIST(STBOX); + LogicalType list_stbox = LogicalType::LIST(stbox); loader.RegisterFunction(ScalarFunction( "spaceBoxes", {TGEOM, DBL, DBL, DBL}, list_stbox, space_boxes_exec)); @@ -990,18 +784,6 @@ void TGeographyOps::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "douglasPeuckerSimplify", {TGEOM, DBL, LogicalType::BOOLEAN}, TGEOM, simplify_double_bool_exec_factory(temporal_simplify_dp))); - - // tgeo_teq / tgeo_tne — temporal equality predicates (geometry × tgeo). - // The MEOS teq_*/tne_* exports work on Temporal* regardless of subtype. -#define REG_TCMP(NAME, FN) \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_geo_tgeo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_geo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_tgeo)); - REG_TCMP("tgeo_teq", Teq) - REG_TCMP("tgeo_tne", Tne) - REG_TCMP("temporal_teq", Teq) - REG_TCMP("temporal_tne", Tne) -#undef REG_TCMP } } // namespace duckdb diff --git a/src/geo/tgeometry.cpp b/src/geo/tgeometry.cpp index d95683b1..244e8816 100644 --- a/src/geo/tgeometry.cpp +++ b/src/geo/tgeometry.cpp @@ -25,9 +25,9 @@ extern "C" { namespace duckdb { -LogicalType TGeometryTypes::TGEOMETRY() { +LogicalType TGeometryTypes::tgeometry() { auto type = LogicalType(LogicalTypeId::BLOB); - type.SetAlias("TGEOMETRY"); + type.SetAlias("tgeometry"); return type; } @@ -46,7 +46,7 @@ inline void Tgeo_constructor(DataChunk &args, ExpressionState &state, Vector &re Temporal *tinst = tgeometry_in(input.c_str()); if (!tinst) { - throw InvalidInputException("Invalid TGEOMETRY input: " + input); + throw InvalidInputException("Invalid tgeometry input: " + input); } size_t data_size = temporal_mem_size(tinst); @@ -54,7 +54,7 @@ inline void Tgeo_constructor(DataChunk &args, ExpressionState &state, Vector &re uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(tinst); - throw InvalidInputException("Failed to allocate memory for TGEOMETRY data"); + throw InvalidInputException("Failed to allocate memory for tgeometry data"); } memcpy(data_buffer, tinst, data_size); @@ -413,13 +413,13 @@ inline void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } Span *timespan = temporal_to_tstzspan(temp); if (!timespan) { - throw InvalidInputException("Failed to extract timespan from TGEOMETRY"); + throw InvalidInputException("Failed to extract timespan from tgeometry"); } size_t span_size = sizeof(Span); @@ -463,12 +463,12 @@ inline void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } TInstant *inst = temporal_to_tinstant(temp); if (!inst) { - throw InvalidInputException("Failed to convert TGEOMETRY to TInstant"); + throw InvalidInputException("Failed to convert tgeometry to TInstant"); } size_t inst_size = temporal_mem_size((Temporal*)inst); @@ -513,7 +513,7 @@ inline void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } std::string interp_str = interp_str_t.GetString(); @@ -563,14 +563,14 @@ inline void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); if (!temp1) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } std::string tgeom2 = tgeom2_str_t.GetString(); Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); if (!temp2) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } Temporal *result_temp = temporal_merge(temp1, temp2); @@ -619,7 +619,7 @@ inline void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } const char *subtype_str = temporal_subtype(temp); @@ -655,7 +655,7 @@ inline void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } @@ -688,7 +688,7 @@ inline void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } size_t mem_size = temporal_mem_size(temp); @@ -979,12 +979,12 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMETRY data: insufficient size"); + throw InvalidInputException("Invalid tgeometry data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOMETRY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeometry deserialization"); } memcpy(data_copy, data, data_size); @@ -992,7 +992,7 @@ inline void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } TimestampTz meos_t = temp->t; @@ -1032,19 +1032,19 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector size_t data_size = tgeom_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMETRY data: insufficient size"); + throw InvalidInputException("Invalid tgeometry data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOMETRY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeometry deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } std::string interp_string = interp_str.GetString(); @@ -1091,87 +1091,82 @@ inline void ExecuteTGeometrySeq(DataChunk &args, ExpressionState &state, Vector void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeometry_function = ScalarFunction( - "TGEOMETRY", + "tgeometry", {LogicalType::VARCHAR}, - TGeometryTypes::TGEOMETRY(), + TGeometryTypes::tgeometry(), Tgeo_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_function); auto tgeometry_from_timestamp_function = ScalarFunction( - "TGEOMETRY", + "tgeometry", {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, - TGeometryTypes::TGEOMETRY(), + TGeometryTypes::tgeometry(), Tgeoinst_constructor); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_from_timestamp_function); auto tgeometry_from_tstzspan_function = ScalarFunction( - "TGEOMETRY", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, - TGeometryTypes::TGEOMETRY(), + "tgeometry", + {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_from_tstzspan_function); auto tgeometry_from_tstzspan_default = ScalarFunction( - "TGEOMETRY", - {LogicalType::VARCHAR, SpanTypes::TSTZSPAN()}, - TGeometryTypes::TGEOMETRY(), + "tgeometry", + {LogicalType::VARCHAR, SpanTypes::tstzspan()}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_from_tstzspan_default); auto tgeometryseqarr_1param= ScalarFunction( "tgeometrySeq", - {LogicalType::LIST(TGeometryTypes::TGEOMETRY())}, - TGeometryTypes::TGEOMETRY(), + {LogicalType::LIST(TGeometryTypes::tgeometry())}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tgeometryseqarr_1param); auto tgeometryseqarr_2params = ScalarFunction( "tgeometrySeq", - {LogicalType::LIST(TGeometryTypes::TGEOMETRY()), LogicalType::VARCHAR}, - TGeometryTypes::TGEOMETRY(), + {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::VARCHAR}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tgeometryseqarr_2params); auto tgeometryseqarr_3params = ScalarFunction( "tgeometrySeq", - {LogicalType::LIST(TGeometryTypes::TGEOMETRY()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - TGeometryTypes::TGEOMETRY(), + {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tgeometryseqarr_3params); auto tgeometryseqarr_4params = ScalarFunction( "tgeometrySeq", - {LogicalType::LIST(TGeometryTypes::TGEOMETRY()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - TGeometryTypes::TGEOMETRY(), + {LogicalType::LIST(TGeometryTypes::tgeometry()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TGeometryTypes::tgeometry(), Tgeometry_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tgeometryseqarr_4params); - auto tgeometry_to_timespan_function = ScalarFunction( - "timeSpan", - {TGeometryTypes::TGEOMETRY()}, - SpanTypes::TSTZSPAN(), - Temporal_to_tstzspan); - duckdb::RegisterSerializedScalarFunction(loader, tgeometry_to_timespan_function); + // timeSpan(tgeometry) is generated (meos_temporal_conversion, RETIRED_GROUPS). auto tgeometry_to_tinstant_function = ScalarFunction( "tgeometryInst", - {TGeometryTypes::TGEOMETRY()}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry()}, + TGeometryTypes::tgeometry(), Temporal_to_tinstant); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_to_tinstant_function); auto setInterp_function = ScalarFunction( "setInterp", - {TGeometryTypes::TGEOMETRY(), LogicalType::VARCHAR}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry(), LogicalType::VARCHAR}, + TGeometryTypes::tgeometry(), Temporal_set_interp ); duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); @@ -1179,15 +1174,15 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto merge_function = ScalarFunction( "merge", - {TGeometryTypes::TGEOMETRY(), TGeometryTypes::TGEOMETRY()}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry()}, + TGeometryTypes::tgeometry(), Temporal_merge ); duckdb::RegisterSerializedScalarFunction(loader, merge_function); auto tempSubtype_function = ScalarFunction( "tempSubtype", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Temporal_subtype ); @@ -1195,7 +1190,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto interp_function = ScalarFunction( "interp", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Temporal_interp ); @@ -1203,7 +1198,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto memSize_function = ScalarFunction( "memSize", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::INTEGER, Temporal_mem_size ); @@ -1211,7 +1206,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto getValue_function = ScalarFunction( "getValue", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, GeoTypes::GEOMETRY(), Tinstant_value ); @@ -1220,7 +1215,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeometry_start_value_function = ScalarFunction( "startValue", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, GeoTypes::GEOMETRY(), Temporal_start_value ); @@ -1228,7 +1223,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeometry_end_value_function = ScalarFunction( "endValue", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, GeoTypes::GEOMETRY(), Temporal_end_value ); @@ -1236,24 +1231,24 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto startInstant_function = ScalarFunction( "startInstant", - {TGeometryTypes::TGEOMETRY()}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry()}, + TGeometryTypes::tgeometry(), Temporal_start_instant ); duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); auto endInstant_function = ScalarFunction( "endInstant", - {TGeometryTypes::TGEOMETRY()}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry()}, + TGeometryTypes::tgeometry(), Temporal_end_instant ); duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); auto instantN_function = ScalarFunction( "instantN", - {TGeometryTypes::TGEOMETRY(), LogicalType::INTEGER}, - TGeometryTypes::TGEOMETRY(), + {TGeometryTypes::tgeometry(), LogicalType::INTEGER}, + TGeometryTypes::tgeometry(), Temporal_instant_n ); duckdb::RegisterSerializedScalarFunction(loader, instantN_function); @@ -1261,7 +1256,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tgeometry_gettimestamptz_function = ScalarFunction( "getTimestamp", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::TIMESTAMP_TZ, Tinstant_timestamptz); duckdb::RegisterSerializedScalarFunction(loader, tgeometry_gettimestamptz_function); @@ -1274,7 +1269,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // generic handlers wired for tgeompoint in temporal_functions.cpp. // =================================================================== - const LogicalType TGEOM = TGeometryTypes::TGEOMETRY(); + const LogicalType TGEOM = TGeometryTypes::tgeometry(); const LogicalType GEOM = GeoTypes::GEOMETRY(); const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; const LogicalType IVAL = LogicalType::INTERVAL; @@ -1329,9 +1324,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "numTimestamps", {TGEOM}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_timestamps)); - loader.RegisterFunction(ScalarFunction( - "timestamps", {TGEOM}, LogicalType::LIST(TSTZ), - TemporalFunctions::Temporal_timestamps)); + // timestamps(tgeometry) is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. loader.RegisterFunction(ScalarFunction( "startTimestamp", {TGEOM}, TSTZ, TemporalFunctions::Temporal_start_timestamptz)); @@ -1349,7 +1342,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_at_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_at_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_at_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_at_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_at_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "atTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -1357,7 +1350,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { for (const auto &t : std::vector>{ {TSTZ, TemporalFunctions::Temporal_minus_timestamptz}, {SetTypes::tstzset(), TemporalFunctions::Temporal_minus_tstzset}, - {SpanTypes::TSTZSPAN(), TemporalFunctions::Temporal_minus_tstzspan}, + {SpanTypes::tstzspan(), TemporalFunctions::Temporal_minus_tstzspan}, {SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_minus_tstzspanset}}) { loader.RegisterFunction(ScalarFunction( "minusTime", {TGEOM, t.first}, TGEOM, t.second)); @@ -1399,7 +1392,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { "minusGeometry", {TGEOM, GEOM}, TGEOM, TgeompointFunctions::Tgeo_minus_geom)); loader.RegisterFunction(ScalarFunction( - "minusStbox", {TGEOM, StboxType::STBOX()}, TGEOM, + "minusStbox", {TGEOM, StboxType::stbox()}, TGEOM, TgeompointFunctions::Tgeo_minus_stbox)); // ---- Modifiers (shift / scale / shiftScale / append / insert / update / @@ -1444,10 +1437,10 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { "deleteTime", {TGEOM, SetTypes::tstzset(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzset)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN()}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan()}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( - "deleteTime", {TGEOM, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, TGEOM, + "deleteTime", {TGEOM, SpanTypes::tstzspan(), LogicalType::BOOLEAN}, TGEOM, TemporalFunctions::Temporal_delete_tstzspan)); loader.RegisterFunction(ScalarFunction( "deleteTime", {TGEOM, SpansetTypes::tstzspanset()}, TGEOM, @@ -1493,7 +1486,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } void TGeometryTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TGEOMETRY", TGeometryTypes::TGEOMETRY()); + loader.RegisterType( "tgeometry", TGeometryTypes::tgeometry()); } diff --git a/src/geo/tgeometry_in_out.cpp b/src/geo/tgeometry_in_out.cpp index 7c8d5a87..35d6c47c 100644 --- a/src/geo/tgeometry_in_out.cpp +++ b/src/geo/tgeometry_in_out.cpp @@ -26,12 +26,12 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMETRY data: insufficient size"); + throw InvalidInputException("Invalid tgeometry data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOMETRY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeometry deserialization"); } memcpy(data_copy, data, data_size); @@ -39,14 +39,14 @@ inline void Tspatial_as_text(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } char *str = tspatial_as_text(temp, 0); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOMETRY to text"); + throw InvalidInputException("Failed to convert tgeometry to text"); } std::string result_str(str); @@ -76,12 +76,12 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMETRY data: insufficient size"); + throw InvalidInputException("Invalid tgeometry data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOMETRY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeometry deserialization"); } memcpy(data_copy, data, data_size); @@ -89,14 +89,14 @@ inline void Tspatial_as_ewkt(DataChunk &args, ExpressionState &state, Vector &re if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } char *ewkt = tspatial_as_ewkt(temp, 0); if (!ewkt) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOMETRY to EWKT"); + throw InvalidInputException("Failed to convert tgeometry to EWKT"); } std::string result_str(ewkt); @@ -124,14 +124,14 @@ bool TgeometryFunctions::StringToTgeometry(Vector &source, Vector &result, idx_t Temporal *temp = tgeometry_in(input_str.c_str()); if (!temp) { - throw InvalidInputException("Invalid TGEOMETRY input: " + input_str); + throw InvalidInputException("Invalid tgeometry input: " + input_str); } size_t data_size = temporal_mem_size(temp); uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(temp); - throw InvalidInputException("Failed to allocate memory for TGEOMETRY data"); + throw InvalidInputException("Failed to allocate memory for tgeometry data"); } memcpy(data_buffer, temp, data_size); @@ -159,25 +159,25 @@ bool TgeometryFunctions::TgeometryToString(Vector &source, Vector &result, idx_t size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMETRY data: insufficient size"); + throw InvalidInputException("Invalid tgeometry data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TGEOMETRY deserialization"); + throw InvalidInputException("Failed to allocate memory for tgeometry deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMETRY data: null pointer"); + throw InvalidInputException("Invalid tgeometry data: null pointer"); } char *str = temporal_out(temp, 15); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOMETRY to string"); + throw InvalidInputException("Failed to convert tgeometry to string"); } std::string output(str); @@ -253,7 +253,7 @@ inline void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &r void TGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeometryAsText = ScalarFunction( "asText", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Tspatial_as_text ); @@ -261,7 +261,7 @@ void TGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ auto TgeometryAsEWKT = ScalarFunction( "asEWKT", - {TGeometryTypes::TGEOMETRY()}, + {TGeometryTypes::tgeometry()}, LogicalType::VARCHAR, Tspatial_as_ewkt ); @@ -270,7 +270,7 @@ void TGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ // ---- tgeometryFromBinary / FromEWKB (auto-detects format) ---- const auto B = LogicalType::BLOB; const auto V = LogicalType::VARCHAR; - const auto T = TGeometryTypes::TGEOMETRY(); + const auto T = TGeometryTypes::tgeometry(); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tgeometryFromBinary", {B}, T, TspatialFromWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, @@ -292,8 +292,8 @@ void TGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TGeometryTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TGeometryTypes::TGEOMETRY(), TgeometryFunctions::StringToTgeometry); - loader.RegisterCastFunction( TGeometryTypes::TGEOMETRY(), LogicalType::VARCHAR, TgeometryFunctions::TgeometryToString); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TGeometryTypes::tgeometry(), TgeometryFunctions::StringToTgeometry); + RegisterMeosCastFunction(loader, TGeometryTypes::tgeometry(), LogicalType::VARCHAR, TgeometryFunctions::TgeometryToString); } } diff --git a/src/geo/tgeometry_ops.cpp b/src/geo/tgeometry_ops.cpp index c094961f..03264f5c 100644 --- a/src/geo/tgeometry_ops.cpp +++ b/src/geo/tgeometry_ops.cpp @@ -265,7 +265,7 @@ inline string_t TemporalToBlob(Vector &result, Temporal *t) { return out; } -template +template void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -273,14 +273,14 @@ void TgeoGeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, false, false); + Temporal *r = FN(t, gs); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -288,21 +288,21 @@ void GeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, false, false); + Temporal *r = FN(gs, t); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, false, false); + Temporal *r = FN(t1, t2); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -310,7 +310,7 @@ void TgeoTgeoTempExec(DataChunk &args, ExpressionState &, Vector &result) { } // tDwithin variants take an extra distance argument. -template +template void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -318,14 +318,14 @@ void TgeoGeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(t, gs, dist, false, false); + Temporal *r = FN(t, gs, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), @@ -333,21 +333,21 @@ void GeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { Temporal *t = DecodeTemporalCopy(t_blob); int32 srid = tspatial_srid(t); GSERIALIZED *gs = GeometryToGSerialized(g_blob, srid); - Temporal *r = FN(gs, t, dist, false, false); + Temporal *r = FN(gs, t, dist); free(t); free(gs); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); }); } -template +template void TgeoTgeoDistTempExec(DataChunk &args, ExpressionState &, Vector &result) { TernaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], args.data[2], result, args.size(), [&](string_t a, string_t b, double dist, ValidityMask &mask, idx_t idx) -> string_t { Temporal *t1 = DecodeTemporalCopy(a); Temporal *t2 = DecodeTemporalCopy(b); - Temporal *r = FN(t1, t2, dist, false, false); + Temporal *r = FN(t1, t2, dist); free(t1); free(t2); if (!r) { mask.SetInvalid(idx); return string_t(); } return TemporalToBlob(result, r); @@ -530,238 +530,32 @@ void TgeoTraversedAreaExec(DataChunk &args, ExpressionState &, Vector &result) { } // namespace void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { - const LogicalType TGEOM = TGeometryTypes::TGEOMETRY(); + const LogicalType TGEOM = TGeometryTypes::tgeometry(); const LogicalType GEOM = GeoTypes::GEOMETRY(); - const LogicalType STBOX = StboxType::STBOX(); - const LogicalType TSTZSPAN = SpanTypes::TSTZSPAN(); + const LogicalType stbox = StboxType::stbox(); + const LogicalType tstzspan = SpanTypes::tstzspan(); const LogicalType BOOL = LogicalType::BOOLEAN; const LogicalType DBL = LogicalType::DOUBLE; - const LogicalType TFLOAT = TemporalTypes::TFLOAT(); - - // ----------------------------------------------------------------- - // Box predicates: temporal_(overlaps|contains|contained|same|adjacent) - // and the equivalent operators (&&, @>, <@, ~=, -|-). - // ----------------------------------------------------------------- - struct BoxOp { - const char *fn_name; - const char *op_name; - bool (*tspatial_stbox)(const Temporal *, const STBox *); - bool (*tspatial_tspatial)(const Temporal *, const Temporal *); - bool (*temporal_tstzspan)(const Temporal *, const Span *); - bool (*tstzspan_temporal)(const Span *, const Temporal *); - }; - const BoxOp box_ops[] = { - {"temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal}, - {"temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal}, - {"temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal}, - {"temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal}, - {"temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal}, - }; + const LogicalType tfloat = TemporalTypes::tfloat(); - // Build per-overload registrations through static dispatch on the - // function pointer values supplied above. We can't bind those to - // template parameters at runtime, so we register each predicate - // explicitly below using the macros. -#define BOX_REG(NAME, OP, F_TSPAT_STBOX, F_TSPAT_TSPAT, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TGEOM, TSTZSPAN},BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(OP, {TSTZSPAN, TGEOM},BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - - BOX_REG("temporal_overlaps", "&&", - overlaps_tspatial_stbox, overlaps_tspatial_tspatial, - overlaps_temporal_tstzspan, overlaps_tstzspan_temporal); - BOX_REG("temporal_contains", "@>", - contains_tspatial_stbox, contains_tspatial_tspatial, - contains_temporal_tstzspan, contains_tstzspan_temporal); - BOX_REG("temporal_contained", "<@", - contained_tspatial_stbox, contained_tspatial_tspatial, - contained_temporal_tstzspan, contained_tstzspan_temporal); - BOX_REG("temporal_same", "~=", - same_tspatial_stbox, same_tspatial_tspatial, - same_temporal_tstzspan, same_tstzspan_temporal); - BOX_REG("temporal_adjacent", "-|-", - adjacent_tspatial_stbox, adjacent_tspatial_tspatial, - adjacent_temporal_tstzspan, adjacent_tstzspan_temporal); -#undef BOX_REG + // Time-axis position predicates on tgeometry × tstzspan (both directions; + // before/after/overbefore/overafter, backing fns before_temporal_tstzspan etc. + // @ingroup meos_temporal_bbox_pos) are generated from the catalog sqlSignatures + // in src/generated/generated_temporal_udfs.cpp. The stale-snake temporal_* + // aliases are dropped (bare names supersede them). - // ----------------------------------------------------------------- - // Position predicates (left / right / below / above / front / back / - // before / after and their over-* variants). Only tgeometry × stbox - // and tgeometry × tgeometry — there are no time-axis positions for - // a tstzspan input that aren't already covered by the time-domain - // predicates wired in `temporal.cpp` for arbitrary temporals. - // ----------------------------------------------------------------- -#define POS_REG(NAME, F_TSPAT_STBOX, F_TSPAT_TSPAT) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, STBOX}, BOOL, \ - TspatialStboxBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {STBOX, TGEOM}, BOOL, \ - StboxTspatialBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TspatialTspatialBoolExec)); \ - } while (0) - - POS_REG("temporal_left", left_tspatial_stbox, left_tspatial_tspatial); - POS_REG("temporal_overleft", overleft_tspatial_stbox, overleft_tspatial_tspatial); - POS_REG("temporal_right", right_tspatial_stbox, right_tspatial_tspatial); - POS_REG("temporal_overright", overright_tspatial_stbox, overright_tspatial_tspatial); - POS_REG("temporal_below", below_tspatial_stbox, below_tspatial_tspatial); - POS_REG("temporal_overbelow", overbelow_tspatial_stbox, overbelow_tspatial_tspatial); - POS_REG("temporal_above", above_tspatial_stbox, above_tspatial_tspatial); - POS_REG("temporal_overabove", overabove_tspatial_stbox, overabove_tspatial_tspatial); - POS_REG("temporal_front", front_tspatial_stbox, front_tspatial_tspatial); - POS_REG("temporal_overfront", overfront_tspatial_stbox, overfront_tspatial_tspatial); - POS_REG("temporal_back", back_tspatial_stbox, back_tspatial_tspatial); - POS_REG("temporal_overback", overback_tspatial_stbox, overback_tspatial_tspatial); - POS_REG("temporal_before", before_tspatial_stbox, before_tspatial_tspatial); - POS_REG("temporal_overbefore", overbefore_tspatial_stbox, overbefore_tspatial_tspatial); - POS_REG("temporal_after", after_tspatial_stbox, after_tspatial_tspatial); - POS_REG("temporal_overafter", overafter_tspatial_stbox, overafter_tspatial_tspatial); -#undef POS_REG - - // Time-axis position predicates also accept a tstzspan operand on the - // non-tspatial side — these reuse the generic temporal_* MEOS exports - // rather than the tspatial_* ones since they don't touch the spatial - // axes. -#define TIME_POS_REG(NAME, F_TEMP_TSTZSPAN, F_TSTZSPAN_TEMP) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TSTZSPAN}, BOOL, \ - TemporalTstzspanBoolExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TSTZSPAN, TGEOM}, BOOL, \ - TstzspanTemporalBoolExec)); \ - } while (0) - TIME_POS_REG("temporal_before", before_temporal_tstzspan, before_tstzspan_temporal); - TIME_POS_REG("temporal_overbefore", overbefore_temporal_tstzspan, overbefore_tstzspan_temporal); - TIME_POS_REG("temporal_after", after_temporal_tstzspan, after_tstzspan_temporal); - TIME_POS_REG("temporal_overafter", overafter_temporal_tstzspan, overafter_tstzspan_temporal); -#undef TIME_POS_REG - - // ----------------------------------------------------------------- - // Spatial relationships — ever (e*) and always (a*) versions for - // contains / disjoint / intersects / touches / dwithin. - // ----------------------------------------------------------------- -#define EA_REG_2(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - GeoTgeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - // disjoint / intersects / touches don't have a (geo, tgeo) MEOS export - // because they are commutative — eDisjoint(g, t) is just eDisjoint(t, g). -#define EA_REG_2_COMMUT(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, BOOL, \ - TgeoGeoIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, BOOL, \ - TgeoTgeoIntExec)); \ - } while (0) - - // contains is non-commutative — uses both directions. - EA_REG_2("eContains", econtains_tgeo_geo, econtains_geo_tgeo, econtains_tgeo_tgeo); - EA_REG_2("aContains", acontains_tgeo_geo, acontains_geo_tgeo, acontains_tgeo_tgeo); - - EA_REG_2_COMMUT("eDisjoint", edisjoint_tgeo_geo, edisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("aDisjoint", adisjoint_tgeo_geo, adisjoint_tgeo_tgeo); - EA_REG_2_COMMUT("eIntersects", eintersects_tgeo_geo, eintersects_tgeo_tgeo); - EA_REG_2_COMMUT("aIntersects", aintersects_tgeo_geo, aintersects_tgeo_tgeo); - EA_REG_2_COMMUT("eTouches", etouches_tgeo_geo, etouches_tgeo_tgeo); - EA_REG_2_COMMUT("aTouches", atouches_tgeo_geo, atouches_tgeo_tgeo); -#undef EA_REG_2 -#undef EA_REG_2_COMMUT - - // dwithin is symmetric in its first two arguments; MEOS only exports - // the (Temporal *, GSERIALIZED *) flavour, so the (geo, tgeo, dist) - // SQL form reuses it with arguments swapped at the call site. -#define EA_DWITHIN_REG(NAME, F_TGEO_GEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM, DBL}, BOOL, \ - GeoTgeoDistIntExec_FromTgeoGeo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM, DBL}, BOOL, \ - TgeoGeoDistIntExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM, DBL}, BOOL, \ - TgeoTgeoDistIntExec)); \ - } while (0) - EA_DWITHIN_REG("eDwithin", edwithin_tgeo_geo, edwithin_tgeo_tgeo); - EA_DWITHIN_REG("aDwithin", adwithin_tgeo_geo, adwithin_tgeo_tgeo); -#undef EA_DWITHIN_REG - - // ----------------------------------------------------------------- - // Temporal spatial relationships (`tContains`, `tDisjoint`, - // `tIntersects`, `tTouches`, `tDwithin`) — return a temporal - // boolean whose truth value tracks the relation over time. - // ----------------------------------------------------------------- -#define TREL_REG(NAME, F_TGEO_GEO, F_GEO_TGEO, F_TGEO_TGEO) \ - do { \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, TemporalTypes::TBOOL(), \ - GeoTgeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, TemporalTypes::TBOOL(), \ - TgeoGeoTempExec)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, TemporalTypes::TBOOL(), \ - TgeoTgeoTempExec)); \ - } while (0) - - TREL_REG("tContains", tcontains_tgeo_geo, tcontains_geo_tgeo, tcontains_tgeo_tgeo); - TREL_REG("tDisjoint", tdisjoint_tgeo_geo, tdisjoint_geo_tgeo, tdisjoint_tgeo_tgeo); - TREL_REG("tIntersects", tintersects_tgeo_geo, tintersects_geo_tgeo, tintersects_tgeo_tgeo); - TREL_REG("tTouches", ttouches_tgeo_geo, ttouches_geo_tgeo, ttouches_tgeo_tgeo); -#undef TREL_REG - - // tDwithin takes the extra distance argument. - loader.RegisterFunction(ScalarFunction("tDwithin", - {GEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - GeoTgeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, GEOM, DBL}, TemporalTypes::TBOOL(), - TgeoGeoDistTempExec)); - loader.RegisterFunction(ScalarFunction("tDwithin", - {TGEOM, TGEOM, DBL}, TemporalTypes::TBOOL(), - TgeoTgeoDistTempExec)); // ----------------------------------------------------------------- // Distance — `tdistance(...)` and `<->`. // ----------------------------------------------------------------- loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("tdistance", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, GEOM}, TFLOAT, TgeoGeoDistanceExec)); + {TGEOM, GEOM}, tfloat, TgeoGeoDistanceExec)); loader.RegisterFunction(ScalarFunction("<->", - {TGEOM, TGEOM}, TFLOAT, TgeoTgeoDistanceExec)); + {TGEOM, TGEOM}, tfloat, TgeoTgeoDistanceExec)); // ----------------------------------------------------------------- // Spatial functions: SRID accessor / setter, projection / transform, @@ -780,14 +574,14 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { // tgeometry → stbox is a cast in the SQL surface; expose it as a // function for now to keep the implementation a single template. loader.RegisterFunction(ScalarFunction( - "stbox", {TGEOM}, STBOX, TspatialToStboxExec)); + "stbox", {TGEOM}, stbox, TspatialToStboxExec)); // tgeometry <-> tgeompoint coercion functions. loader.RegisterFunction(ScalarFunction( - "tgeompoint", {TGEOM}, TgeompointType::TGEOMPOINT(), + "tgeompoint", {TGEOM}, TgeompointType::tgeompoint(), TgeometryToTgeompointExec)); loader.RegisterFunction(ScalarFunction( - "tgeometry", {TgeompointType::TGEOMPOINT()}, TGEOM, + "tgeometry", {TgeompointType::tgeompoint()}, TGEOM, TgeompointToTgeometryExec)); // Centroid / convexHull / traversedArea — produce a non-temporal @@ -860,7 +654,7 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { } }; - LogicalType list_stbox = LogicalType::LIST(STBOX); + LogicalType list_stbox = LogicalType::LIST(stbox); loader.RegisterFunction(ScalarFunction( "spaceBoxes", {TGEOM, DBL, DBL, DBL}, list_stbox, space_boxes_exec)); @@ -986,19 +780,6 @@ void TGeometryOps::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "douglasPeuckerSimplify", {TGEOM, DBL, LogicalType::BOOLEAN}, TGEOM, simplify_double_bool_exec_factory(temporal_simplify_dp))); - - // tgeo_teq / tgeo_tne — temporal equality predicates (geometry × tgeo). - // The MEOS teq_*/tne_* exports work on Temporal* regardless of subtype, - // so we reuse the TgeompointFunctions wrappers which cover all 3 forms. -#define REG_TCMP(NAME, FN) \ - loader.RegisterFunction(ScalarFunction(NAME, {GEOM, TGEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_geo_tgeo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, GEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_geo)); \ - loader.RegisterFunction(ScalarFunction(NAME, {TGEOM, TGEOM}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_tgeo)); - REG_TCMP("tgeo_teq", Teq) - REG_TCMP("tgeo_tne", Tne) - REG_TCMP("temporal_teq", Teq) - REG_TCMP("temporal_tne", Tne) -#undef REG_TCMP } } // namespace duckdb diff --git a/src/geo/tgeompoint.cpp b/src/geo/tgeompoint.cpp index 2bc5e6a0..14f79214 100644 --- a/src/geo/tgeompoint.cpp +++ b/src/geo/tgeompoint.cpp @@ -23,38 +23,38 @@ namespace duckdb { -LogicalType TgeompointType::TGEOMPOINT() { +LogicalType TgeompointType::tgeompoint() { LogicalType type(LogicalTypeId::BLOB); - type.SetAlias("TGEOMPOINT"); + type.SetAlias("tgeompoint"); return type; } void TgeompointType::RegisterType(ExtensionLoader &loader) { - loader.RegisterType( "TGEOMPOINT", TGEOMPOINT()); + loader.RegisterType( "tgeompoint", tgeompoint()); } void TgeompointType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, - TGEOMPOINT(), + tgeompoint(), TgeompointFunctions::Tpoint_in ); - loader.RegisterCastFunction( - TGEOMPOINT(), + RegisterMeosCastFunction(loader, + tgeompoint(), LogicalType::VARCHAR, TemporalFunctions::Temporal_out ); - loader.RegisterCastFunction( - TGEOMPOINT(), - StboxType::STBOX(), + RegisterMeosCastFunction(loader, + tgeompoint(), + StboxType::stbox(), TgeompointFunctions::Tspatial_to_stbox_cast ); - loader.RegisterCastFunction( - TGEOMPOINT(), - SpanTypes::TSTZSPAN(), + RegisterMeosCastFunction(loader, + tgeompoint(), + SpanTypes::tstzspan(), TgeompointFunctions::Temporal_to_tstzspan_cast ); } @@ -68,7 +68,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::VARCHAR, TgeompointFunctions::Tspatial_as_text ) @@ -77,7 +77,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::VARCHAR, TgeompointFunctions::Tspatial_as_ewkt ) @@ -88,7 +88,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {LogicalType::LIST(TGEOMPOINT())}, + {LogicalType::LIST(tgeompoint())}, varchar_list, TgeompointFunctions::Spatialarr_as_text ) @@ -96,7 +96,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asText", - {LogicalType::LIST(TGEOMPOINT()), LogicalType::INTEGER}, + {LogicalType::LIST(tgeompoint()), LogicalType::INTEGER}, varchar_list, TgeompointFunctions::Spatialarr_as_text ) @@ -121,7 +121,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {LogicalType::LIST(TGEOMPOINT())}, + {LogicalType::LIST(tgeompoint())}, varchar_list, TgeompointFunctions::Spatialarr_as_ewkt ) @@ -129,7 +129,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "asEWKT", - {LogicalType::LIST(TGEOMPOINT()), LogicalType::INTEGER}, + {LogicalType::LIST(tgeompoint()), LogicalType::INTEGER}, varchar_list, TgeompointFunctions::Spatialarr_as_ewkt ) @@ -156,18 +156,18 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { ****************************************************/ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "TGEOMPOINT", + "tgeompoint", {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + tgeompoint(), TgeompointFunctions::Tpointinst_constructor ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "TGEOMPOINT", + "tgeompoint", {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ, LogicalType::INTEGER}, // with SRID - TGEOMPOINT(), + tgeompoint(), TgeompointFunctions::Tpointinst_constructor ) ); @@ -176,7 +176,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeompoint", {GeoTypes::GEOMETRY(), SetTypes::tstzset()}, - TGEOMPOINT(), + tgeompoint(), TemporalFunctions::Tsequence_from_base_tstzset ) ); @@ -184,8 +184,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompoint", - {GeoTypes::GEOMETRY(), SpanTypes::TSTZSPAN()}, - TGEOMPOINT(), + {GeoTypes::GEOMETRY(), SpanTypes::tstzspan()}, + tgeompoint(), TemporalFunctions::Tsequence_from_base_tstzspan ) ); @@ -193,8 +193,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompoint", - {GeoTypes::GEOMETRY(), SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, - TGEOMPOINT(), + {GeoTypes::GEOMETRY(), SpanTypes::tstzspan(), LogicalType::VARCHAR}, + tgeompoint(), TemporalFunctions::Tsequence_from_base_tstzspan ) ); @@ -203,7 +203,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeompoint", {GeoTypes::GEOMETRY(), SpansetTypes::tstzspanset()}, - TGEOMPOINT(), + tgeompoint(), TemporalFunctions::Tsequenceset_from_base_tstzspanset ) ); @@ -212,7 +212,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tgeompoint", {GeoTypes::GEOMETRY(), SpansetTypes::tstzspanset(), LogicalType::VARCHAR}, - TGEOMPOINT(), + tgeompoint(), TemporalFunctions::Tsequenceset_from_base_tstzspanset ) ); @@ -220,8 +220,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeq", - {LogicalType::LIST(TGEOMPOINT())}, - TGEOMPOINT(), + {LogicalType::LIST(tgeompoint())}, + tgeompoint(), // TemporalFunctions::Tsequence_constructor TgeompointFunctions::Tgeompoint_sequence_constructor ) @@ -230,8 +230,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeqSet", - {LogicalType::LIST(TGEOMPOINT())}, - TGEOMPOINT(), + {LogicalType::LIST(tgeompoint())}, + tgeompoint(), TemporalFunctions::Tsequenceset_constructor ) ); @@ -239,8 +239,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stbox", - {TGEOMPOINT()}, - StboxType::STBOX(), + {tgeompoint()}, + StboxType::stbox(), TgeompointFunctions::Tspatial_to_stbox ) ); @@ -248,14 +248,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { /* *************************************************** * Conversion functions ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timeSpan", - {TGEOMPOINT()}, - SpanTypes::TSTZSPAN(), - TgeompointFunctions::Temporal_to_tstzspan - ) - ); + // timeSpan(tgeompoint) (temporal_to_tstzspan, group meos_temporal_conversion) is + // generated from the catalog in generated_temporal_udfs.cpp (RETIRED_GROUPS). /*************************************************** * Transformation functions @@ -264,8 +258,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointInst", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_to_tinstant ) ); @@ -273,8 +267,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeq", - {TGEOMPOINT(), LogicalType::VARCHAR}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::VARCHAR}, + tgeompoint(), TemporalFunctions::Temporal_to_tsequence ) ); @@ -282,8 +276,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeq", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_to_tsequence ) ); @@ -291,8 +285,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeqSet", - {TGEOMPOINT(), LogicalType::VARCHAR}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::VARCHAR}, + tgeompoint(), TemporalFunctions::Temporal_to_tsequenceset ) ); @@ -300,8 +294,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tgeompointSeqSet", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_to_tsequenceset ) ); @@ -309,8 +303,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "setInterp", - {TGEOMPOINT(), LogicalType::VARCHAR}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::VARCHAR}, + tgeompoint(), TemporalFunctions::Temporal_set_interp ) ); @@ -318,8 +312,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "appendInstant", - {TGEOMPOINT(), TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_append_tinstant ) ); @@ -327,8 +321,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "appendSequence", - {TGEOMPOINT(), TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_append_tsequence ) ); @@ -336,8 +330,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "merge", - {TGEOMPOINT(), TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_merge ) ); @@ -345,8 +339,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "merge", - {LogicalType::LIST(TGEOMPOINT())}, - TGEOMPOINT(), + {LogicalType::LIST(tgeompoint())}, + tgeompoint(), TemporalFunctions::Temporal_merge_array ) ); @@ -357,7 +351,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tempSubtype", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::VARCHAR, TemporalFunctions::Temporal_subtype ) @@ -366,7 +360,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "interp", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::VARCHAR, TemporalFunctions::Temporal_interp ) @@ -375,7 +369,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getValue", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_value ) @@ -384,7 +378,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getTimestamp", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Tinstant_timestamptz ) @@ -393,7 +387,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueSet", - {TGEOMPOINT()}, + {tgeompoint()}, SpatialSetType::geomset(), TemporalFunctions::Temporal_valueset ) @@ -407,7 +401,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { // arg (BinaryExecutor). Registering // INTEGER here made DuckDB 1.4 reject the bind with // "Expected INT64, found INT32" (tgeompoint.test:482). - {TGEOMPOINT(), LogicalType::BIGINT}, + {tgeompoint(), LogicalType::BIGINT}, GeoTypes::GEOMETRY(), TemporalFunctions::Temporal_value_n ) @@ -416,7 +410,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getTime", - {TGEOMPOINT()}, + {tgeompoint()}, SpansetTypes::tstzspanset(), TemporalFunctions::Temporal_time ) @@ -425,7 +419,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startValue", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_start_value ) @@ -434,7 +428,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endValue", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tgeompoint_end_value ) @@ -442,7 +436,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "duration", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::INTERVAL, TemporalFunctions::Temporal_duration ) @@ -451,7 +445,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "duration", - {TGEOMPOINT(), LogicalType::BOOLEAN}, + {tgeompoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, TemporalFunctions::Temporal_duration ) @@ -460,7 +454,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "memSize", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_mem_size ) @@ -469,7 +463,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "lowerInc", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lower_inc ) @@ -478,7 +472,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "upperInc", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_upper_inc ) @@ -487,7 +481,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numInstants", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_instants ) @@ -496,8 +490,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startInstant", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_start_instant ) ); @@ -505,8 +499,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endInstant", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_end_instant ) ); @@ -514,8 +508,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "instantN", - {TGEOMPOINT(), LogicalType::INTEGER}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTEGER}, + tgeompoint(), TemporalFunctions::Temporal_instant_n ) ); @@ -523,8 +517,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "instants", - {TGEOMPOINT()}, - LogicalType::LIST(TGEOMPOINT()), + {tgeompoint()}, + LogicalType::LIST(tgeompoint()), TemporalFunctions::Temporal_instants ) ); @@ -532,7 +526,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numTimestamps", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_timestamps ) @@ -540,7 +534,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startTimestamp", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_start_timestamptz ) @@ -549,7 +543,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endTimestamp", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_end_timestamptz ) @@ -558,25 +552,18 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "timestampN", - {TGEOMPOINT(), LogicalType::INTEGER}, + {tgeompoint(), LogicalType::INTEGER}, LogicalType::TIMESTAMP_TZ, TemporalFunctions::Temporal_timestamptz_n ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timestamps", - {TGEOMPOINT()}, - LogicalType::LIST(LogicalType::TIMESTAMP_TZ), - TemporalFunctions::Temporal_timestamps - ) - ); + // timestamps(tgeompoint) is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "numSequences", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_num_sequences ) @@ -585,8 +572,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "startSequence", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_start_sequence ) ); @@ -594,8 +581,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "endSequence", - {TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_end_sequence ) ); @@ -603,8 +590,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "sequenceN", - {TGEOMPOINT(), LogicalType::INTEGER}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTEGER}, + tgeompoint(), TemporalFunctions::Temporal_sequence_n ) ); @@ -612,8 +599,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "sequences", - {TGEOMPOINT()}, - LogicalType::LIST(TGEOMPOINT()), + {tgeompoint()}, + LogicalType::LIST(tgeompoint()), TemporalFunctions::Temporal_sequences ) ); @@ -621,8 +608,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "segments", - {TGEOMPOINT()}, - LogicalType::LIST(TGEOMPOINT()), + {tgeompoint()}, + LogicalType::LIST(tgeompoint()), TemporalFunctions::Temporal_segments ) ); @@ -633,8 +620,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftTime", - {TGEOMPOINT(), LogicalType::INTERVAL}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTERVAL}, + tgeompoint(), TemporalFunctions::Temporal_shift_time ) ); @@ -642,8 +629,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleTime", - {TGEOMPOINT(), LogicalType::INTERVAL}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTERVAL}, + tgeompoint(), TemporalFunctions::Temporal_scale_time ) ); @@ -651,8 +638,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleTime", - {TGEOMPOINT(), LogicalType::INTERVAL, LogicalType::INTERVAL}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTERVAL, LogicalType::INTERVAL}, + tgeompoint(), TemporalFunctions::Temporal_shift_scale_time ) ); @@ -666,8 +653,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TGEOMPOINT(), + {tgeompoint(), GeoTypes::GEOMETRY()}, + tgeompoint(), TgeompointFunctions::Tgeompoint_at_value ) ); @@ -675,8 +662,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TGEOMPOINT(), + {tgeompoint(), GeoTypes::GEOMETRY()}, + tgeompoint(), TemporalFunctions::Temporal_minus_value ) ); @@ -684,8 +671,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TGEOMPOINT(), SpatialSetType::geomset()}, - TGEOMPOINT(), + {tgeompoint(), SpatialSetType::geomset()}, + tgeompoint(), TemporalFunctions::Temporal_at_values ) ); @@ -693,8 +680,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TGEOMPOINT(), SpatialSetType::geomset()}, - TGEOMPOINT(), + {tgeompoint(), SpatialSetType::geomset()}, + tgeompoint(), TemporalFunctions::Temporal_minus_value ) ); @@ -702,8 +689,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, + tgeompoint(), TemporalFunctions::Temporal_at_timestamptz ) ); @@ -711,8 +698,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, + tgeompoint(), TemporalFunctions::Temporal_minus_timestamptz ) ); @@ -720,7 +707,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueAtTimestamp", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, GeoTypes::GEOMETRY(), TemporalFunctions::Temporal_value_at_timestamptz ) @@ -729,8 +716,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOMPOINT(), SetTypes::tstzset()}, - TGEOMPOINT(), + {tgeompoint(), SetTypes::tstzset()}, + tgeompoint(), TemporalFunctions::Temporal_at_tstzset ) ); @@ -738,8 +725,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOMPOINT(), SetTypes::tstzset()}, - TGEOMPOINT(), + {tgeompoint(), SetTypes::tstzset()}, + tgeompoint(), TemporalFunctions::Temporal_minus_tstzset ) ); @@ -747,8 +734,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOMPOINT(), SpanTypes::TSTZSPAN()}, - TGEOMPOINT(), + {tgeompoint(), SpanTypes::tstzspan()}, + tgeompoint(), TemporalFunctions::Temporal_at_tstzspan ) ); @@ -756,8 +743,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOMPOINT(), SpanTypes::TSTZSPAN()}, - TGEOMPOINT(), + {tgeompoint(), SpanTypes::tstzspan()}, + tgeompoint(), TemporalFunctions::Temporal_minus_tstzspan ) ); @@ -765,8 +752,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {TGEOMPOINT(), SpansetTypes::tstzspanset()}, - TGEOMPOINT(), + {tgeompoint(), SpansetTypes::tstzspanset()}, + tgeompoint(), TemporalFunctions::Temporal_at_tstzspanset ) ); @@ -774,8 +761,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {TGEOMPOINT(), SpansetTypes::tstzspanset()}, - TGEOMPOINT(), + {tgeompoint(), SpansetTypes::tstzspanset()}, + tgeompoint(), TemporalFunctions::Temporal_minus_tstzspanset ) ); @@ -783,8 +770,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "beforeTimestamp", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, + tgeompoint(), TemporalFunctions::Temporal_before_timestamptz ) ); @@ -792,8 +779,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "afterTimestamp", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, + tgeompoint(), TemporalFunctions::Temporal_after_timestamptz ) ); @@ -804,8 +791,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "insert", - {TGEOMPOINT(), TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_update ) ); @@ -813,8 +800,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "insert", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint(), LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_update ) ); @@ -822,8 +809,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "update", - {TGEOMPOINT(), TGEOMPOINT()}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint()}, + tgeompoint(), TemporalFunctions::Temporal_update ) ); @@ -831,8 +818,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "update", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), tgeompoint(), LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_update ) ); @@ -840,16 +827,16 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ}, + tgeompoint(), TemporalFunctions::Temporal_delete_timestamptz ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::TIMESTAMP_TZ, LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_delete_timestamptz ) ); @@ -857,16 +844,16 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SetTypes::tstzset()}, - TGEOMPOINT(), + {tgeompoint(), SetTypes::tstzset()}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzset ) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SetTypes::tstzset(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), SetTypes::tstzset(), LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzset ) ); @@ -874,8 +861,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SpanTypes::TSTZSPAN()}, - TGEOMPOINT(), + {tgeompoint(), SpanTypes::tstzspan()}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzspan ) ); @@ -883,8 +870,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), SpanTypes::tstzspan(), LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzspan ) ); @@ -892,8 +879,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SpansetTypes::tstzspanset()}, - TGEOMPOINT(), + {tgeompoint(), SpansetTypes::tstzspanset()}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzspanset ) ); @@ -901,8 +888,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {TGEOMPOINT(), SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), SpansetTypes::tstzspanset(), LogicalType::BOOLEAN}, + tgeompoint(), TemporalFunctions::Temporal_delete_tstzspanset ) ); @@ -915,8 +902,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "stops", - {TGEOMPOINT(), LogicalType::DOUBLE, LogicalType::INTERVAL}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::DOUBLE, LogicalType::INTERVAL}, + tgeompoint(), TgeompointFunctions::Tgeompoint_stops ) ); @@ -927,7 +914,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_eq", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_eq ) @@ -936,7 +923,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_ne", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ne ) @@ -945,7 +932,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_lt", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lt ) @@ -954,7 +941,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_le", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_le ) @@ -963,7 +950,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_gt", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_gt ) @@ -972,7 +959,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_ge", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ge ) @@ -981,7 +968,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "temporal_cmp", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::INTEGER, TemporalFunctions::Temporal_cmp ) @@ -990,7 +977,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "=", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_eq ) @@ -999,7 +986,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<>", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ne ) @@ -1008,7 +995,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_lt ) @@ -1017,7 +1004,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<=", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_le ) @@ -1026,7 +1013,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_gt ) @@ -1035,7 +1022,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">=", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, LogicalType::BOOLEAN, TemporalFunctions::Temporal_ge ) @@ -1047,8 +1034,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getX", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_x ) ); @@ -1056,8 +1043,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getY", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_y ) ); @@ -1065,8 +1052,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getZ", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_get_z ) ); @@ -1074,7 +1061,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "length", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::DOUBLE, TgeompointFunctions::Tpoint_length ) @@ -1083,8 +1070,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "cumulativeLength", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_cumulative_length ) ); @@ -1092,8 +1079,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "speed", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TemporalFunctions::Temporal_derivative ) ); @@ -1101,7 +1088,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "twCentroid", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_twcentroid ) @@ -1110,8 +1097,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "direction", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_direction ) ); @@ -1119,8 +1106,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "azimuth", - {TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tpoint_azimuth ) ); @@ -1128,7 +1115,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "angularDifference", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_angular_difference ) @@ -1137,7 +1124,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "isSimple", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::BOOLEAN, TgeompointFunctions::Tpoint_is_simple ) @@ -1146,8 +1133,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "makeSimple", - {TGEOMPOINT()}, - LogicalType::LIST(TGEOMPOINT()), + {tgeompoint()}, + LogicalType::LIST(tgeompoint()), TgeompointFunctions::Tpoint_make_simple ) ); @@ -1155,7 +1142,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "trajectory", - {TGEOMPOINT()}, + {tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::Tpoint_trajectory ) @@ -1164,7 +1151,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "trajectory_gs", - {TGEOMPOINT()}, + {tgeompoint()}, LogicalType::BLOB, TgeompointFunctions::Tpoint_trajectory_gs ) @@ -1173,8 +1160,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atGeometry", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TGEOMPOINT(), + {tgeompoint(), GeoTypes::GEOMETRY()}, + tgeompoint(), TgeompointFunctions::Tgeo_at_geom ) ); @@ -1182,8 +1169,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusGeometry", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TGEOMPOINT(), + {tgeompoint(), GeoTypes::GEOMETRY()}, + tgeompoint(), TgeompointFunctions::Tgeo_minus_geom ) ); @@ -1191,8 +1178,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusGeometry", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), SpanTypes::FLOATSPAN()}, - TGEOMPOINT(), + {tgeompoint(), GeoTypes::GEOMETRY(), SpanTypes::floatspan()}, + tgeompoint(), TgeompointFunctions::Tgeo_minus_geom ) ); @@ -1200,8 +1187,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atStbox", - {TGEOMPOINT(), StboxType::STBOX()}, - TGEOMPOINT(), + {tgeompoint(), StboxType::stbox()}, + tgeompoint(), TgeompointFunctions::Tgeo_at_stbox ) ); @@ -1209,8 +1196,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atStbox", - {TGEOMPOINT(), StboxType::STBOX(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), StboxType::stbox(), LogicalType::BOOLEAN}, + tgeompoint(), TgeompointFunctions::Tgeo_at_stbox ) ); @@ -1218,8 +1205,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusStbox", - {TGEOMPOINT(), StboxType::STBOX()}, - TGEOMPOINT(), + {tgeompoint(), StboxType::stbox()}, + tgeompoint(), TgeompointFunctions::Tgeo_minus_stbox ) ); @@ -1227,8 +1214,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusStbox", - {TGEOMPOINT(), StboxType::STBOX(), LogicalType::BOOLEAN}, - TGEOMPOINT(), + {tgeompoint(), StboxType::stbox(), LogicalType::BOOLEAN}, + tgeompoint(), TgeompointFunctions::Tgeo_minus_stbox ) ); @@ -1236,459 +1223,16 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "transform", - {TGEOMPOINT(), LogicalType::INTEGER}, - TGEOMPOINT(), + {tgeompoint(), LogicalType::INTEGER}, + tgeompoint(), TgeompointFunctions::Tspatial_transform ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TGEOMPOINT(), LogicalType::INTEGER}, - TGEOMPOINT(), - TemporalFunctions::Temporal_round - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TGEOMPOINT()}, - TGEOMPOINT(), - TemporalFunctions::Temporal_round - ) - ); - - /* *************************************************** - * Spatial relationships - ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eContains", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Econtains_geo_tgeo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aContains", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Acontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDisjoint", - {TGEOMPOINT(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDisjoint", - {TGEOMPOINT(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_tgeo_geo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eIntersects", - {TGEOMPOINT(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Eintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_tgeo_geo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aIntersects", - {TGEOMPOINT(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Aintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eTouches", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Etouches_geo_tpoint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eTouches", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Etouches_tpoint_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aTouches", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Atouches_geo_tpoint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aTouches", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - LogicalType::BOOLEAN, - TgeompointFunctions::Atouches_tpoint_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "eDwithin", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Edwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "aDwithin", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::DOUBLE}, - LogicalType::BOOLEAN, - TgeompointFunctions::Adwithin_tgeo_tgeo - ) - ); - - /* *************************************************** - * Temporal-spatial relationships - ****************************************************/ - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tContains", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tcontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tContains", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tcontains_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDisjoint", - {TGEOMPOINT(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdisjoint_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_geo_tgeo - ) - ); + // round(tgeompoint) at both arities is generated from the catalog temporal_round + // signature (generated_temporal_udfs.cpp); no hand registration remains. - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_tgeo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tIntersects", - {TGEOMPOINT(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tintersects_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_geo_tgeo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {GeoTypes::GEOMETRY(), TGEOMPOINT()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_geo_tgeo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_tgeo_geo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tTouches", - {TGEOMPOINT(), GeoTypes::GEOMETRY()}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Ttouches_tgeo_geo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_geo_tgeo - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {GeoTypes::GEOMETRY(), TGEOMPOINT(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_geo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOMPOINT(), GeoTypes::GEOMETRY(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_geo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::DOUBLE}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_tgeo - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tDwithin", - {TGEOMPOINT(), TGEOMPOINT(), LogicalType::DOUBLE, LogicalType::BOOLEAN}, - TemporalTypes::TBOOL(), - TgeompointFunctions::Tdwithin_tgeo_tgeo - ) - ); /* *************************************************** @@ -1698,7 +1242,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", // overlaps - {TGEOMPOINT(), StboxType::STBOX()}, + {tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_overlaps_tgeompoint_stbox ) @@ -1707,7 +1251,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", // overlaps - {TGEOMPOINT(), SpanTypes::TSTZSPAN()}, + {tgeompoint(), SpanTypes::tstzspan()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan ) @@ -1716,7 +1260,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "@>", // contains - {TGEOMPOINT(), StboxType::STBOX()}, + {tgeompoint(), StboxType::stbox()}, LogicalType::BOOLEAN, TgeompointFunctions::Temporal_contains_tgeompoint_stbox ) @@ -1729,8 +1273,8 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<->", - {TGEOMPOINT(), TGEOMPOINT()}, - TemporalTypes::TFLOAT(), + {tgeompoint(), tgeompoint()}, + TemporalTypes::tfloat(), TgeompointFunctions::Tdistance_tgeo_tgeo ) ); @@ -1738,7 +1282,7 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shortestLine", - {TGEOMPOINT(), TGEOMPOINT()}, + {tgeompoint(), tgeompoint()}, GeoTypes::GEOMETRY(), TgeompointFunctions::ShortestLine_tgeo_tgeo ) @@ -1778,38 +1322,21 @@ void TgeompointType::RegisterScalarFunctions(ExtensionLoader &loader) { * on tgeompoint × {geometry, tgeompoint} ****************************************************/ { - const auto T = TGEOMPOINT(); + const auto T = tgeompoint(); const auto G = GeoTypes::GEOMETRY(); -#define REG_SPATIAL_EA(NAME, FN) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {G, T}, LogicalType::BOOLEAN, TgeompointFunctions::FN##_geo_tgeo)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {T, G}, LogicalType::BOOLEAN, TgeompointFunctions::FN##_tgeo_geo)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {T, T}, LogicalType::BOOLEAN, TgeompointFunctions::FN##_tgeo_tgeo)); - - REG_SPATIAL_EA("ever_eq", Ever_eq) - REG_SPATIAL_EA("always_eq", Always_eq) - REG_SPATIAL_EA("ever_ne", Ever_ne) - REG_SPATIAL_EA("always_ne", Always_ne) -#undef REG_SPATIAL_EA - -#define REG_SPATIAL_TCMP(NAME, FN) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {G, T}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_geo_tgeo)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {T, G}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_geo)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {T, T}, TemporalTypes::TBOOL(), TgeompointFunctions::FN##_tgeo_tgeo)); - - REG_SPATIAL_TCMP("temporal_teq", Teq) - REG_SPATIAL_TCMP("temporal_tne", Tne) - // Portable-SQL aliases (MobilityDB names): tgeo_teq / tgeo_tne - REG_SPATIAL_TCMP("tgeo_teq", Teq) - REG_SPATIAL_TCMP("tgeo_tne", Tne) -#undef REG_SPATIAL_TCMP + // ever/always spatial comparisons (meos_temporal_comp_ever) are supplied by + // the generated surface (geometry-arg overloads via the Temporal+GSERIALIZED path). + + // spatial temporal comparisons tEq/tNe (meos_temporal_comp_temp) are supplied + // by the generated surface (geometry-arg overloads via the Temporal+GSERIALIZED path). } /* tdistance named form (mirrors the <-> operator) */ { - const auto TG = TGEOMPOINT(); + const auto TG = tgeompoint(); const auto G = GeoTypes::GEOMETRY(); - const auto TF = TemporalTypes::TFLOAT(); + const auto TF = TemporalTypes::tfloat(); const auto D = LogicalType::DOUBLE; duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tdistance", {TG, TG}, TF, TgeompointFunctions::Tdistance_named)); @@ -2048,12 +1575,12 @@ void TgeoAsMVTGeomExec(DataChunk &args, ExpressionState &state, Vector &result) if (cc > 3) buffer = FlatVector::GetData(args.data[3])[row]; if (cc > 4) clip = FlatVector::GetData(args.data[4])[row]; - GSERIALIZED *geom = nullptr; - int64 *times = nullptr; - int count = 0; - bool found = tpoint_as_mvtgeom(t, bx, extent, buffer, clip, &geom, ×, &count); + MvtGeom mvt = tpoint_as_mvtgeom(t, bx, extent, buffer, clip); free(t); free(bx); - if (!found || !geom) { + GSERIALIZED *geom = mvt.geom; + int64 *times = mvt.times; + int count = mvt.count; + if (!geom) { out_validity.SetInvalid(row); times_entries[row] = list_entry_t{total_times, 0}; if (geom) free(geom); @@ -2131,7 +1658,7 @@ struct SpaceSplitGlobalState : public GlobalTableFunctionState { /* space_bins[i] is the raw EWKB serialisation of the i-th spatial bin * (GSERIALIZED -> EWKB at Init time, decoded into the result vector's * geometry format at Exec time using DuckDB-spatial's wkb_reader). - * tpoint blobs are pre-built TGEOMPOINT-aliased BLOB values. + * tpoint blobs are pre-built tgeompoint-aliased BLOB values. * time_bin is populated only by the spaceTimeSplit overload. */ std::vector> space_ewkb; std::vector time_bin; @@ -2185,10 +1712,10 @@ unique_ptr SpaceSplitBindCommon(ClientContext &context, } if (with_time) { - return_types = {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ, TgeompointType::TGEOMPOINT()}; + return_types = {GeoTypes::GEOMETRY(), LogicalType::TIMESTAMP_TZ, TgeompointType::tgeompoint()}; names = {"spaceBin", "timeBin", "tpoint"}; } else { - return_types = {GeoTypes::GEOMETRY(), TgeompointType::TGEOMPOINT()}; + return_types = {GeoTypes::GEOMETRY(), TgeompointType::tgeompoint()}; names = {"spaceBin", "tpoint"}; } return std::move(bd); @@ -2232,12 +1759,18 @@ unique_ptr SpaceSplitInitCommon(ClientContext &context if (bind.has_torigin) { torigin = (TimestampTz) DuckDBToMeosTimestamp(bind.torigin).value; } - trajs = tgeo_space_time_split(temp, bind.xsize, bind.ysize, bind.zsize, - &mi, origin, torigin, bind.bitmatrix, true, - &bins, &tbins, &count); + SpaceTimeSplit sts = tgeo_space_time_split(temp, bind.xsize, bind.ysize, bind.zsize, + &mi, origin, torigin, bind.bitmatrix, true); + trajs = sts.fragments; + bins = sts.space_bins; + tbins = sts.time_bins; + count = sts.count; } else { - trajs = tgeo_space_split(temp, bind.xsize, bind.ysize, bind.zsize, - origin, bind.bitmatrix, true, &bins, &count); + SpaceSplit ss = tgeo_space_split(temp, bind.xsize, bind.ysize, bind.zsize, + origin, bind.bitmatrix, true); + trajs = ss.fragments; + bins = ss.bins; + count = ss.count; } free(temp); free(origin); @@ -2273,7 +1806,7 @@ unique_ptr SpaceSplitInitCommon(ClientContext &context size_t sz = temporal_mem_size(trajs[i]); Value tblob = Value::BLOB(reinterpret_cast(trajs[i]), sz); - tblob.Reinterpret(TgeompointType::TGEOMPOINT()); + tblob.Reinterpret(TgeompointType::tgeompoint()); state->tpoint.push_back(std::move(tblob)); free(trajs[i]); } @@ -2379,7 +1912,7 @@ void TgeoGeoMeasureExec(DataChunk &args, ExpressionState &state, Vector &result) } // namespace void TgeompointType::RegisterRoundtripIO(ExtensionLoader &loader) { - const auto T = TGEOMPOINT(); + const auto T = tgeompoint(); const auto V = LogicalType::VARCHAR; const auto B = LogicalType::BLOB; const auto BL = LogicalType::BOOLEAN; @@ -2391,9 +1924,8 @@ void TgeompointType::RegisterRoundtripIO(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asEWKB", {T}, B, [](DataChunk &a, ExpressionState &s, Vector &r) { TgeoAsWkbExec(a, s, r, WKB_EXTENDED); })); - /* asHexWKB / asHexEWKB */ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {T}, V, - [](DataChunk &a, ExpressionState &s, Vector &r) { TgeoAsHexWkbExec(a, s, r, WKB_BASE); })); + /* asHexEWKB (extended hex-WKB, includes SRID). asHexWKB (base) is generated from the + * catalog as the inherited Temporal output surface (generated_temporal_udfs.cpp). */ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asHexEWKB", {T}, V, [](DataChunk &a, ExpressionState &s, Vector &r) { TgeoAsHexWkbExec(a, s, r, WKB_EXTENDED); })); @@ -2421,7 +1953,7 @@ void TgeompointType::RegisterRoundtripIO(ExtensionLoader &loader) { } void TgeompointType::RegisterTpointSplit(ExtensionLoader &loader) { - const auto T = TGEOMPOINT(); + const auto T = tgeompoint(); const auto D = LogicalType::DOUBLE; const auto I = LogicalType::INTERVAL; const auto TS = LogicalType::TIMESTAMP_TZ; @@ -2457,8 +1989,8 @@ void TgeompointType::RegisterTpointSplit(ExtensionLoader &loader) { } void TgeompointType::RegisterAnalyticsViz(ExtensionLoader &loader) { - const auto T = TGEOMPOINT(); - const auto B = StboxType::STBOX(); + const auto T = tgeompoint(); + const auto B = StboxType::stbox(); const auto G = GeoTypes::GEOMETRY(); const auto I = LogicalType::INTEGER; const auto BL = LogicalType::BOOLEAN; @@ -2474,8 +2006,8 @@ void TgeompointType::RegisterAnalyticsViz(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("asMVTGeom", {T, B, I, I, BL}, MVT_OUT, TgeoAsMVTGeomExec)); /* geoMeasure(tgeompoint, tfloat[, segmentize]) -> geometry */ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("geoMeasure", {T, TemporalTypes::TFLOAT()}, G, TgeoGeoMeasureExec)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("geoMeasure", {T, TemporalTypes::TFLOAT(), BL}, G, TgeoGeoMeasureExec)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("geoMeasure", {T, TemporalTypes::tfloat()}, G, TgeoGeoMeasureExec)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("geoMeasure", {T, TemporalTypes::tfloat(), BL}, G, TgeoGeoMeasureExec)); } } // namespace duckdb diff --git a/src/geo/tgeompoint_functions.cpp b/src/geo/tgeompoint_functions.cpp index e23464c0..0d960101 100644 --- a/src/geo/tgeompoint_functions.cpp +++ b/src/geo/tgeompoint_functions.cpp @@ -25,23 +25,6 @@ namespace duckdb { namespace { -inline int ea_disjoint_geo_tgeo_dispatch(const GSERIALIZED *gs, const Temporal *temp, bool ever) { - return ever ? edisjoint_tgeo_geo(temp, gs) : adisjoint_tgeo_geo(temp, gs); -} - -inline int ea_intersects_geo_tgeo_dispatch(const GSERIALIZED *gs, const Temporal *temp, bool ever) { - return ever ? eintersects_tgeo_geo(temp, gs) : aintersects_tgeo_geo(temp, gs); -} - -/* MobilityDB EA_spatialrel_geo_tspatial style: (gs, temp, …); MEOS uses (temp, gs, …). */ -inline int ea_dwithin_geo_tgeo_dispatch(const GSERIALIZED *gs, const Temporal *temp, double dist, bool ever) { - return ever ? edwithin_tgeo_geo(temp, gs, dist) : adwithin_tgeo_geo(temp, gs, dist); -} - -inline int ea_touches_tpoint_geo_dispatch(const GSERIALIZED *gs, const Temporal *temp, bool ever) { - return ever ? etouches_tpoint_geo(temp, gs) : atouches_tpoint_geo(temp, gs); -} - enum class SpatialarrElemKind { TGEOM_POINT, GEOMETRY_BLOB }; static SpatialarrElemKind spatialarr_elem_kind_from_list(const LogicalType &list_type) { @@ -50,7 +33,7 @@ static SpatialarrElemKind spatialarr_elem_kind_from_list(const LogicalType &list } const auto &child = ListType::GetChildType(list_type); const auto &alias = child.GetAlias(); - if (alias == "TGEOMPOINT" || alias == "TGEOGPOINT") { + if (alias == "tgeompoint" || alias == "tgeogpoint") { return SpatialarrElemKind::TGEOM_POINT; } if (alias == "GEOMETRY") { @@ -172,14 +155,14 @@ bool TgeompointFunctions::Tpoint_in(Vector &source, Vector &result, idx_t count, Temporal *temp = tgeompoint_in(input_str.c_str()); if (!temp) { - throw InvalidInputException("Invalid TGEOMPOINT input: " + input_str); + throw InvalidInputException("Invalid tgeompoint input: " + input_str); } size_t data_size = temporal_mem_size(temp); uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(temp); - throw InvalidInputException("Failed to allocate memory for TGEOMPOINT"); + throw InvalidInputException("Failed to allocate memory for tgeompoint"); } memcpy(data_buffer, temp, data_size); @@ -205,20 +188,20 @@ void TgeompointFunctions::Tspatial_as_text(DataChunk &args, ExpressionState &sta const uint8_t *data = reinterpret_cast(input_blob.GetData()); size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeompoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT input: " + input_blob.GetString()); + throw InvalidInputException("Invalid tgeompoint input: " + input_blob.GetString()); } char* ret = tspatial_as_text(temp, 15); if (!ret) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOMPOINT to text: " + input_blob.GetString()); + throw InvalidInputException("Failed to convert tgeompoint to text: " + input_blob.GetString()); } std::string ret_string(ret); string_t stored_data = StringVector::AddStringOrBlob(result, ret_string); @@ -240,20 +223,20 @@ void TgeompointFunctions::Tspatial_as_ewkt(DataChunk &args, ExpressionState &sta const uint8_t *data = reinterpret_cast(input_blob.GetData()); size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeompoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT input: " + input_blob.GetString()); + throw InvalidInputException("Invalid tgeompoint input: " + input_blob.GetString()); } char *ewkt = tspatial_as_ewkt(temp, OUT_DEFAULT_DECIMAL_DIGITS); if (!ewkt) { free(data_copy); - throw InvalidInputException("Failed to convert TGEOMPOINT to EWKT: " + input_blob.GetString()); + throw InvalidInputException("Failed to convert tgeompoint to EWKT: " + input_blob.GetString()); } std::string ret_string(ewkt); string_t stored_data = StringVector::AddStringOrBlob(result, ret_string); @@ -298,7 +281,7 @@ void TgeompointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat Temporal *ret = (Temporal *) tpointinst_make(gs, static_cast(ts_meos.value)); if (ret == NULL) { free(gs); - throw InvalidInputException("Failed to create TGEOMPOINT from geometry and timestamp"); + throw InvalidInputException("Failed to create tgeompoint from geometry and timestamp"); } size_t ret_size = temporal_mem_size(ret); @@ -306,7 +289,7 @@ void TgeompointFunctions::Tpointinst_constructor(DataChunk &args, ExpressionStat if (!ret_data) { free(ret); free(gs); - throw InvalidInputException("Failed to allocate memory for TGEOMPOINT"); + throw InvalidInputException("Failed to allocate memory for tgeompoint"); } memcpy(ret_data, ret, ret_size); @@ -334,13 +317,13 @@ inline void Tspatial_to_stbox_common(Vector &source, Vector &result, idx_t count Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); return string_t(); } STBox *stbox = tspatial_to_stbox(temp); if (!stbox) { free(temp); - throw InvalidInputException("Failed to convert TGEOMPOINT to STBOX"); + throw InvalidInputException("Failed to convert tgeompoint to stbox"); return string_t(); } @@ -348,7 +331,7 @@ inline void Tspatial_to_stbox_common(Vector &source, Vector &result, idx_t count uint8_t *stbox_data = (uint8_t*)malloc(stbox_size); if (!stbox_data) { free(temp); - throw InvalidInputException("Failed to allocate memory for STBOX"); + throw InvalidInputException("Failed to allocate memory for stbox"); return string_t(); } memcpy(stbox_data, stbox, stbox_size); @@ -387,7 +370,7 @@ void TgeompointFunctions::Tgeompoint_start_value(DataChunk &args, ExpressionStat Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); return string_t(); } @@ -395,7 +378,7 @@ void TgeompointFunctions::Tgeompoint_start_value(DataChunk &args, ExpressionStat GSERIALIZED *start_geom = DatumGetGserializedP(start_datum); if (!start_geom) { free(temp); - throw InvalidInputException("Failed to get start value from TGEOMPOINT"); + throw InvalidInputException("Failed to get start value from tgeompoint"); } string_t geometry_blob = GSerializedToGeometry(start_geom, state, result); @@ -422,7 +405,7 @@ void TgeompointFunctions::Tgeompoint_end_value(DataChunk &args, ExpressionState Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); return string_t(); } @@ -430,7 +413,7 @@ void TgeompointFunctions::Tgeompoint_end_value(DataChunk &args, ExpressionState GSERIALIZED *end_geom = DatumGetGserializedP(end_datum); if (!end_geom) { free(temp); - throw InvalidInputException("Failed to get end value from TGEOMPOINT"); + throw InvalidInputException("Failed to get end value from tgeompoint"); } string_t geometry_blob = GSerializedToGeometry(end_geom, state, result); @@ -454,8 +437,8 @@ void TgeompointFunctions::Tgeompoint_sequence_constructor(DataChunk &args, Expre auto arg_count = args.ColumnCount(); auto row_count = args.size(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); - interpType interp = temptype_continuous(temptype) ? LINEAR : STEP; + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; bool lower_inc = true; bool upper_inc = true; @@ -618,7 +601,7 @@ void TgeompointFunctions::Tgeompoint_value(DataChunk &args, ExpressionState &sta Temporal *temp = reinterpret_cast(tgeom_data_copy); if (!temp) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } if (temp->subtype != TINSTANT) { free(temp); @@ -660,7 +643,7 @@ void TgeompointFunctions::Tgeompoint_at_value(DataChunk &args, ExpressionState & Temporal *temp = reinterpret_cast(tgeom_data_copy); if (!temp) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } int32 srid = tspatial_srid(temp); @@ -709,7 +692,7 @@ void TgeompointFunctions::Tgeompoint_value_at_timestamptz(DataChunk &args, Expre Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } timestamp_tz_t ts_meos = DuckDBToMeosTimestamp(ts_duckdb); @@ -753,7 +736,7 @@ void TgeompointFunctions::Tgeompoint_stops(DataChunk &args, ExpressionState &sta Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } MeosInterval minduration = IntervaltToInterval(minduration_duckdb); TSequenceSet *ret = temporal_stops(temp, maxdist, &minduration); @@ -792,12 +775,12 @@ void TgeompointFunctions::Tpoint_get_x(DataChunk &args, ExpressionState &state, Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_get_x(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to get X coordinate from TGEOMPOINT"); + throw InvalidInputException("Failed to get X coordinate from tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -825,12 +808,12 @@ void TgeompointFunctions::Tpoint_get_y(DataChunk &args, ExpressionState &state, Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_get_y(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to get Y coordinate from TGEOMPOINT"); + throw InvalidInputException("Failed to get Y coordinate from tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -858,12 +841,12 @@ void TgeompointFunctions::Tpoint_get_z(DataChunk &args, ExpressionState &state, Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_get_z(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to get Z coordinate from TGEOMPOINT"); + throw InvalidInputException("Failed to get Z coordinate from tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -891,7 +874,7 @@ void TgeompointFunctions::Tpoint_length(DataChunk &args, ExpressionState &state, Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } double ret = tpoint_length(temp); free(temp); @@ -914,12 +897,12 @@ void TgeompointFunctions::Tpoint_cumulative_length(DataChunk &args, ExpressionSt Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_cumulative_length(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to compute cumulative length of TGEOMPOINT"); + throw InvalidInputException("Failed to compute cumulative length of tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -947,12 +930,12 @@ void TgeompointFunctions::Tpoint_twcentroid(DataChunk &args, ExpressionState &st Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } GSERIALIZED *ret = tpoint_twcentroid(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to compute time-weighted centroid of TGEOMPOINT"); + throw InvalidInputException("Failed to compute time-weighted centroid of tgeompoint"); } string_t geometry_blob = GSerializedToGeometry(ret, state, result); string_t stored_result = StringVector::AddStringOrBlob(result, geometry_blob); @@ -976,13 +959,13 @@ void TgeompointFunctions::Tpoint_direction(DataChunk &args, ExpressionState &sta Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } double ret; bool has_direction = tpoint_direction(temp, &ret); if (!has_direction) { free(temp); - throw InvalidInputException("Failed to compute direction of TGEOMPOINT"); + throw InvalidInputException("Failed to compute direction of tgeompoint"); } free(temp); return ret; @@ -1004,12 +987,12 @@ void TgeompointFunctions::Tpoint_azimuth(DataChunk &args, ExpressionState &state Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_azimuth(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to compute azimuth of TGEOMPOINT"); + throw InvalidInputException("Failed to compute azimuth of tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -1037,12 +1020,12 @@ void TgeompointFunctions::Tpoint_angular_difference(DataChunk &args, ExpressionS Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tpoint_angular_difference(temp); free(temp); if (!ret) { - throw InvalidInputException("Failed to compute angular difference of TGEOMPOINT"); + throw InvalidInputException("Failed to compute angular difference of tgeompoint"); } size_t ret_size = temporal_mem_size(ret); uint8_t *ret_data = (uint8_t*)malloc(ret_size); @@ -1070,7 +1053,7 @@ void TgeompointFunctions::Tpoint_is_simple(DataChunk &args, ExpressionState &sta Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } bool ret = tpoint_is_simple(temp); free(temp); @@ -1090,14 +1073,14 @@ void TgeompointFunctions::Tpoint_make_simple(DataChunk &args, ExpressionState &s const uint8_t *data = reinterpret_cast(input_blob.GetData()); size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeompoint data: insufficient size"); } uint8_t *data_copy = (uint8_t *)malloc(data_size); memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } int frag_count = 0; @@ -1158,13 +1141,13 @@ void TgeompointFunctions::Tpoint_trajectory(DataChunk &args, ExpressionState &st Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } GSERIALIZED *gs = tpoint_trajectory(temp, false); if (!gs) { free(temp); - throw InvalidInputException("Failed to get trajectory from TGEOMPOINT"); + throw InvalidInputException("Failed to get trajectory from tgeompoint"); } string_t geometry_blob = GSerializedToGeometry(gs, state, result); @@ -1191,13 +1174,13 @@ void TgeompointFunctions::Tpoint_trajectory_gs(DataChunk &args, ExpressionState Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } GSERIALIZED *gs = tpoint_trajectory(temp, false); if (!gs) { free(temp); - throw InvalidInputException("Failed to get trajectory from TGEOMPOINT"); + throw InvalidInputException("Failed to get trajectory from tgeompoint"); } size_t gs_size = VARSIZE(gs); @@ -1227,7 +1210,7 @@ void TgeompointFunctions::Tgeo_at_geom(DataChunk &args, ExpressionState &state, Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } int32 srid = tspatial_srid(tgeom); @@ -1274,14 +1257,14 @@ void TgeompointFunctions::Tgeo_minus_geom(DataChunk &args, ExpressionState &stat const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); size_t tgeom_data_size = tgeom_blob.GetSize(); if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeompoint data: insufficient size"); } uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } int32 srid = tspatial_srid(tgeom); @@ -1291,7 +1274,7 @@ void TgeompointFunctions::Tgeo_minus_geom(DataChunk &args, ExpressionState &stat throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); } - Temporal *ret = zspan ? tpoint_minus_geom(tgeom, gs, zspan) : tgeo_minus_geom(tgeom, gs); + Temporal *ret = zspan ? tpoint_minus_geom(tgeom, gs) : tgeo_minus_geom(tgeom, gs); free(tgeom); free(gs); if (!ret) { @@ -1359,7 +1342,7 @@ void TgeompointFunctions::Tgeo_minus_stbox(DataChunk &args, ExpressionState &sta Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *stbox_raw = reinterpret_cast(stbox_blob.GetData()); @@ -1370,7 +1353,7 @@ void TgeompointFunctions::Tgeo_minus_stbox(DataChunk &args, ExpressionState &sta if (!stbox) { free(tgeom_data_copy); free(stbox_data_copy); - throw InvalidInputException("Invalid STBOX data: null pointer"); + throw InvalidInputException("Invalid stbox data: null pointer"); } Temporal *ret = tgeo_minus_stbox(tgeom, stbox, border_inc); @@ -1408,7 +1391,7 @@ void TgeompointFunctions::Tgeo_at_stbox(DataChunk &args, ExpressionState &state, Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *stbox_raw = reinterpret_cast(stbox_blob.GetData()); @@ -1419,7 +1402,7 @@ void TgeompointFunctions::Tgeo_at_stbox(DataChunk &args, ExpressionState &state, if (!stbox) { free(tgeom_data_copy); free(stbox_data_copy); - throw InvalidInputException("Invalid STBOX data: null pointer"); + throw InvalidInputException("Invalid stbox data: null pointer"); } Temporal *ret = tgeo_at_stbox(tgeom, stbox, border_inc); @@ -1470,13 +1453,13 @@ void TgeompointFunctions::Tspatial_transform(DataChunk &args, ExpressionState &s Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tspatial_transform(tgeom, srid); if (ret == NULL) { free(tgeom); - throw InvalidInputException("Failed to transform TGEOMPOINT"); + throw InvalidInputException("Failed to transform tgeompoint"); } size_t ret_size = temporal_mem_size(ret); @@ -1484,7 +1467,7 @@ void TgeompointFunctions::Tspatial_transform(DataChunk &args, ExpressionState &s if (!ret_data) { free(ret); free(tgeom); - throw InvalidInputException("Failed to allocate memory for TGEOMPOINT"); + throw InvalidInputException("Failed to allocate memory for tgeompoint"); } memcpy(ret_data, ret, ret_size); @@ -1502,1615 +1485,6 @@ void TgeompointFunctions::Tspatial_transform(DataChunk &args, ExpressionState &s } } -/* *************************************************** - * Spatial relationships - ****************************************************/ -void TgeompointFunctions::Econtains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t*)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = econtains_geo_tgeo(gs, tgeom); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Acontains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t*)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = acontains_geo_tgeo(gs, tgeom); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = ea_disjoint_geo_tgeo_dispatch(gs, tgeom, true); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = edisjoint_tgeo_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int ret = edisjoint_tgeo_tgeo(tgeom1, tgeom2); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - // Same as MobilityDB EA_spatialrel_geo_tspatial(..., &ea_disjoint_geo_tgeo, ALWAYS) - int ret = ea_disjoint_geo_tgeo_dispatch(gs, tgeom, false); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = adisjoint_tgeo_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - // extern int adisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); - int ret = adisjoint_tgeo_tgeo(tgeom1, tgeom2); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Eintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int ret = eintersects_tgeo_tgeo(tgeom1, tgeom2); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Eintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t*)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = ea_intersects_geo_tgeo_dispatch(gs, tgeom, true); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Eintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t*)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = eintersects_tgeo_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Aintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - int ret = ea_intersects_geo_tgeo_dispatch(gs, tgeom, false); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Aintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = aintersects_tgeo_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Aintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int ret = aintersects_tgeo_tgeo(tgeom1, tgeom2); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Etouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - - int ret = ea_touches_tpoint_geo_dispatch(gs, tgeom, true); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Atouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - - int ret = ea_touches_tpoint_geo_dispatch(gs, tgeom, false); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - }); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Etouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = etouches_tpoint_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Atouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = atouches_tpoint_geo(tgeom, gs); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int ret = edwithin_tgeo_tgeo(tgeom1, tgeom2, dist); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t*)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = edwithin_tgeo_geo(tgeom, gs, dist); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Edwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = ea_dwithin_geo_tgeo_dispatch(gs, tgeom, dist, true); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = adwithin_tgeo_geo(tgeom, gs, dist); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - if (tgeom_data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); - } - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - int ret = ea_dwithin_geo_tgeo_dispatch(gs, tgeom, dist, false); - free(tgeom); - free(gs); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Adwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, double dist, ValidityMask &mask, idx_t idx) -> bool { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int ret = adwithin_tgeo_tgeo(tgeom1, tgeom2, dist); - free(tgeom1); - free(tgeom2); - if (ret < 0) { - mask.SetInvalid(idx); - return false; - } - return ret; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -/* *************************************************** - * Temporal-spatial relationships - ****************************************************/ -void TgeompointFunctions::Tcontains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - const idx_t count = args.size(); - auto eval = [&](string_t geometry_blob, string_t tgeom_blob, bool restr, bool at_value, ValidityMask &mask, - idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tcontains_geo_tgeo(gs, tgeom, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = - StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - }; - - if (args.ColumnCount() == 2) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, count, - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> string_t { - return eval(geometry_blob, tgeom_blob, false, false, mask, idx); - }); - } else if (args.ColumnCount() == 3) { - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, count, - [&](string_t geometry_blob, string_t tgeom_blob, bool at_value, ValidityMask &mask, - idx_t idx) -> string_t { - return eval(geometry_blob, tgeom_blob, true, at_value, mask, idx); - }); - } else { - throw InternalException("Tcontains_geo_tgeo: expected 2 or 3 arguments"); - } - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tdisjoint_geo_tgeo(gs, tgeom, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tdisjoint_tgeo_geo(tgeom, gs, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - Temporal *ret = tdisjoint_tgeo_tgeo(tgeom1, tgeom2, restr, at_value); - free(tgeom1); - free(tgeom2); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tintersects_geo_tgeo(gs, tgeom, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tintersects_tgeo_geo(tgeom, gs, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - Temporal *ret = tintersects_tgeo_tgeo(tgeom1, tgeom2, restr, at_value); - free(tgeom1); - free(tgeom2); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Ttouches_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = ttouches_geo_tgeo(gs, tgeom, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Ttouches_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 2){ - at_value = args.data[2].GetValue(0).GetValue(); - restr = true; - } - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = ttouches_tgeo_geo(tgeom, gs, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 3) { - at_value = args.data[3].GetValue(0).GetValue(); - restr = true; - } - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom1_blob, string_t tgeom2_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom1_data = reinterpret_cast(tgeom1_blob.GetData()); - size_t tgeom1_data_size = tgeom1_blob.GetSize(); - uint8_t *tgeom1_data_copy = (uint8_t*)malloc(tgeom1_data_size); - memcpy(tgeom1_data_copy, tgeom1_data, tgeom1_data_size); - Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); - if (!tgeom1) { - free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); - size_t tgeom2_data_size = tgeom2_blob.GetSize(); - uint8_t *tgeom2_data_copy = (uint8_t*)malloc(tgeom2_data_size); - memcpy(tgeom2_data_copy, tgeom2_data, tgeom2_data_size); - Temporal *tgeom2 = reinterpret_cast(tgeom2_data_copy); - if (!tgeom2) { - free(tgeom1); - free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - Temporal *ret = tdwithin_tgeo_tgeo(tgeom1, tgeom2, dist, restr, at_value); - if (!ret) { - free(tgeom1); - free(tgeom2); - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - free(tgeom1); - free(tgeom2); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 3) { - at_value = args.data[3].GetValue(0).GetValue(); - restr = true; - } - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t tgeom_blob, string_t geometry_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tdwithin_tgeo_geo(tgeom, gs, dist, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TgeompointFunctions::Tdwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { - bool at_value = false; - bool restr = false; - if (args.ColumnCount() > 3) { - at_value = args.data[3].GetValue(0).GetValue(); - restr = true; - } - TernaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], args.data[2], result, args.size(), - [&](string_t geometry_blob, string_t tgeom_blob, double dist, ValidityMask &mask, idx_t idx) -> string_t { - const uint8_t *tgeom_data = reinterpret_cast(tgeom_blob.GetData()); - size_t tgeom_data_size = tgeom_blob.GetSize(); - uint8_t *tgeom_data_copy = (uint8_t *)malloc(tgeom_data_size); - memcpy(tgeom_data_copy, tgeom_data, tgeom_data_size); - Temporal *tgeom = reinterpret_cast(tgeom_data_copy); - if (!tgeom) { - free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); - } - - int32 srid = tspatial_srid(tgeom); - GSERIALIZED *gs = GeometryToGSerialized(geometry_blob, srid); - if (!gs) { - free(tgeom); - throw InvalidInputException("Invalid geometry format: " + geometry_blob.GetString()); - } - if (MEOS_FLAGS_GET_GEODETIC(tgeom->flags)) { - GSERIALIZED *gs_geog = geom_to_geog(gs); - free(gs); - gs = gs_geog; - } - - Temporal *ret = tdwithin_geo_tgeo(gs, tgeom, dist, restr, at_value); - free(tgeom); - free(gs); - if (!ret) { - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t stored_data = StringVector::AddStringOrBlob(result, reinterpret_cast(ret), ret_size); - free(ret); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - void TgeompointFunctions::ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, args.size(), @@ -3122,7 +1496,7 @@ void TgeompointFunctions::ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionStat Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); if (!tgeom1) { free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); @@ -3133,7 +1507,7 @@ void TgeompointFunctions::ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionStat if (!tgeom2) { free(tgeom1); free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } GSERIALIZED *ret = shortestline_tgeo_tgeo(tgeom1, tgeom2); if (!ret) { @@ -3170,7 +1544,7 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_stbox(DataChunk &args, Ex Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *stbox_data = reinterpret_cast(stbox_blob.GetData()); @@ -3181,7 +1555,7 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_stbox(DataChunk &args, Ex if (!stbox) { free(tgeom); free(stbox_data_copy); - throw InvalidInputException("Invalid STBOX data: null pointer"); + throw InvalidInputException("Invalid stbox data: null pointer"); } bool ret = overlaps_tspatial_stbox(tgeom, stbox); free(tgeom); @@ -3205,7 +1579,7 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan(DataChunk &args, Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *span_data = reinterpret_cast(span_blob.GetData()); @@ -3216,7 +1590,7 @@ void TgeompointFunctions::Temporal_overlaps_tgeompoint_tstzspan(DataChunk &args, if (!span) { free(tgeom); free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = overlaps_tstzspan_temporal(span, tgeom); free(tgeom); @@ -3240,7 +1614,7 @@ void TgeompointFunctions::Temporal_contains_tgeompoint_stbox(DataChunk &args, Ex Temporal *tgeom = reinterpret_cast(tgeom_data_copy); if (!tgeom) { free(tgeom_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *stbox_data = reinterpret_cast(stbox_blob.GetData()); @@ -3251,7 +1625,7 @@ void TgeompointFunctions::Temporal_contains_tgeompoint_stbox(DataChunk &args, Ex if (!stbox) { free(tgeom); free(stbox_data_copy); - throw InvalidInputException("Invalid STBOX data: null pointer"); + throw InvalidInputException("Invalid stbox data: null pointer"); } bool ret = contains_tspatial_stbox(tgeom, stbox); free(tgeom); @@ -3279,7 +1653,7 @@ void TgeompointFunctions::Tdistance_tgeo_tgeo(DataChunk &args, ExpressionState & Temporal *tgeom1 = reinterpret_cast(tgeom1_data_copy); if (!tgeom1) { free(tgeom1_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } const uint8_t *tgeom2_data = reinterpret_cast(tgeom2_blob.GetData()); @@ -3290,7 +1664,7 @@ void TgeompointFunctions::Tdistance_tgeo_tgeo(DataChunk &args, ExpressionState & if (!tgeom2) { free(tgeom1); free(tgeom2_data_copy); - throw InvalidInputException("Invalid TGEOMPOINT data: null pointer"); + throw InvalidInputException("Invalid tgeompoint data: null pointer"); } Temporal *ret = tdistance_tgeo_tgeo(tgeom1, tgeom2); @@ -3482,7 +1856,7 @@ string_t TemporalToBlobLocal(Vector &result, Temporal *r) { string_t ApplyAffineToTgeoStraggler(Vector &result, string_t input_blob, const AFFINE &m) { size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void *)) { - throw InvalidInputException("Invalid TGEOMPOINT data: insufficient size"); + throw InvalidInputException("Invalid tgeompoint data: insufficient size"); } uint8_t *data_copy = (uint8_t *)malloc(data_size); memcpy(data_copy, input_blob.GetData(), data_size); diff --git a/src/include/cbuffer/tcbuffer.hpp b/src/include/cbuffer/tcbuffer.hpp new file mode 100644 index 00000000..0d9fa7f1 --- /dev/null +++ b/src/include/cbuffer/tcbuffer.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include "meos_wrapper_simple.hpp" +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + +/* cbuffer is a circular buffer (a point + a radius); a varlena value surfaced as + * a BLOB. tcbuffer is its temporal counterpart, stored as a Temporal* blob. + * Canonical names per meos_catalog.c ([T_CBUFFER]="cbuffer", [T_TCBUFFER]="tcbuffer"). + * This binding registers only the type + text I/O boundary; the operation surface + * (constructors, accessors, predicates, distance, …) is generated from the + * MEOS-API catalog into src/generated/. */ +struct CbufferTypes { + static LogicalType cbuffer(); + static LogicalType tcbuffer(); + + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); +}; + +struct CbufferFunctions { + /* In/out — static cbuffer value */ + static bool Cbuffer_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool Cbuffer_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + + /* In/out — tcbuffer temporal value */ + static bool Tcbuffer_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool Tcbuffer_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); +}; + +} // namespace duckdb diff --git a/src/include/geo/stbox.hpp b/src/include/geo/stbox.hpp index 344a6e61..dd487fdb 100644 --- a/src/include/geo/stbox.hpp +++ b/src/include/geo/stbox.hpp @@ -13,7 +13,7 @@ namespace duckdb { class ExtensionLoader; struct StboxType { - static LogicalType STBOX(); + static LogicalType stbox(); static void RegisterType(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); diff --git a/src/include/geo/stbox_functions.hpp b/src/include/geo/stbox_functions.hpp index 2bd041f5..9e5b340c 100644 --- a/src/include/geo/stbox_functions.hpp +++ b/src/include/geo/stbox_functions.hpp @@ -15,14 +15,14 @@ class ExtensionLoader; struct StboxFunctions { /* *************************************************** - * In/out functions: VARCHAR <-> STBOX + * In/out functions: VARCHAR <-> stbox ****************************************************/ static bool Stbox_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static void Stbox_in(DataChunk &args, ExpressionState &state, Vector &result); static bool Stbox_out(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); /* *************************************************** - * In/out functions: WKB/HexWKB <-> STBOX + * In/out functions: WKB/HexWKB <-> stbox ****************************************************/ static void Stbox_from_wkb(DataChunk &args, ExpressionState &state, Vector &result); static void Stbox_from_hexwkb(DataChunk &args, ExpressionState &state, Vector &result); @@ -41,7 +41,7 @@ struct StboxFunctions { static void Geo_tstzspan_to_stbox(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** - * Conversion functions + cast functions: [TYPE] -> STBOX + * Conversion functions + cast functions: [TYPE] -> stbox ****************************************************/ static void Geo_to_stbox_common(Vector &source, Vector &result, idx_t count); static void Geo_to_stbox(DataChunk &args, ExpressionState &state, Vector &result); @@ -56,7 +56,7 @@ struct StboxFunctions { static bool Tstzspanset_to_stbox_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); /* *************************************************** - * Conversion functions + cast functions: STBOX -> [TYPE] + * Conversion functions + cast functions: stbox -> [TYPE] ****************************************************/ static void Stbox_to_geo(DataChunk &args, ExpressionState &state, Vector &result); // static void Stbox_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result); diff --git a/src/include/geo/tgeogpoint.hpp b/src/include/geo/tgeogpoint.hpp index c8553933..fcfee219 100644 --- a/src/include/geo/tgeogpoint.hpp +++ b/src/include/geo/tgeogpoint.hpp @@ -18,7 +18,7 @@ namespace duckdb { class ExtensionLoader; struct TgeogpointType { - static LogicalType TGEOGPOINT(); + static LogicalType tgeogpoint(); static void RegisterType(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); @@ -32,7 +32,7 @@ struct TgeogpointType { // MEOS C functions reached here are subtype-agnostic and shared between // the two types. struct TGeogpointType { - static LogicalType TGEOGPOINT(); + static LogicalType tgeogpoint(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); diff --git a/src/include/geo/tgeography.hpp b/src/include/geo/tgeography.hpp index c59072ff..af42260b 100644 --- a/src/include/geo/tgeography.hpp +++ b/src/include/geo/tgeography.hpp @@ -15,7 +15,7 @@ namespace duckdb { // MEOS C functions reached here are subtype-agnostic and shared between // the two types. struct TGeographyTypes { - static LogicalType TGEOGRAPHY(); + static LogicalType tgeography(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); diff --git a/src/include/geo/tgeometry.hpp b/src/include/geo/tgeometry.hpp index 6be1b64d..993094d8 100644 --- a/src/include/geo/tgeometry.hpp +++ b/src/include/geo/tgeometry.hpp @@ -11,7 +11,7 @@ namespace duckdb { struct TGeometryTypes { - static LogicalType TGEOMETRY(); + static LogicalType tgeometry(); static LogicalType GEOMETRY(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); diff --git a/src/include/geo/tgeompoint.hpp b/src/include/geo/tgeompoint.hpp index 633400cb..b817786f 100644 --- a/src/include/geo/tgeompoint.hpp +++ b/src/include/geo/tgeompoint.hpp @@ -13,7 +13,7 @@ namespace duckdb { class ExtensionLoader; struct TgeompointType { - static LogicalType TGEOMPOINT(); + static LogicalType tgeompoint(); static void RegisterType(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); diff --git a/src/include/geo/tgeompoint_functions.hpp b/src/include/geo/tgeompoint_functions.hpp index 1f5b1eb8..977a267b 100644 --- a/src/include/geo/tgeompoint_functions.hpp +++ b/src/include/geo/tgeompoint_functions.hpp @@ -107,48 +107,6 @@ struct TgeompointFunctions { static void Tgeo_minus_stbox(DataChunk &args, ExpressionState &state, Vector &result); static void Tspatial_transform(DataChunk &args, ExpressionState &state, Vector &result); - /* *************************************************** - * Spatial relationships - ****************************************************/ - static void Econtains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Acontains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Eintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Eintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Eintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Aintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Aintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Aintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Etouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result); - static void Etouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Atouches_geo_tpoint(DataChunk &args, ExpressionState &state, Vector &result); - static void Atouches_tpoint_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Edwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Adwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - /* *************************************************** - * Temporal-spatial relationships - ****************************************************/ - static void Tcontains_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdisjoint_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdisjoint_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdisjoint_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tintersects_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tintersects_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tintersects_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Ttouches_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Ttouches_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdwithin_geo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdwithin_tgeo_geo(DataChunk &args, ExpressionState &state, Vector &result); - static void Tdwithin_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); static void ShortestLine_tgeo_tgeo(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** * Operators (workaround as functions) diff --git a/src/include/geo_util.hpp b/src/include/geo_util.hpp index b832bc6f..a82535c7 100644 --- a/src/include/geo_util.hpp +++ b/src/include/geo_util.hpp @@ -37,7 +37,7 @@ inline bool BlobLooksLikeTemporal(string_t blob) { return false; } uint8_t temptype = static_cast(blob.GetData()[4]); - return tspatial_type(static_cast(temptype)); + return tspatial_type(static_cast(temptype)); } inline GSERIALIZED* GeometryToGSerialized(string_t geometry_blob, int32_t srid) { diff --git a/src/include/index/rtree_module.hpp b/src/include/index/rtree_module.hpp index 5cb45811..5e48e2ad 100644 --- a/src/include/index/rtree_module.hpp +++ b/src/include/index/rtree_module.hpp @@ -70,21 +70,21 @@ class TRTreeIndex : public BoundIndex { bool TryMatchDistanceFunction(const unique_ptr &expr, vector> &bindings) const; - meosType GetBboxType() const { return bbox_type_; } + MeosType GetBboxType() const { return bbox_type_; } size_t GetBboxSize() const { return bbox_size_; } private: case_insensitive_map_t options_; - + unique_ptr function_matcher; unique_ptr MakeFunctionMatcher() const; RTree *rtree_; void *boxes; - meosType bbox_type_; + MeosType bbox_type_; size_t bbox_size_; size_t current_size_ = 0; diff --git a/src/include/meos_wrapper_simple.hpp b/src/include/meos_wrapper_simple.hpp index 5b558be1..a116b16f 100644 --- a/src/include/meos_wrapper_simple.hpp +++ b/src/include/meos_wrapper_simple.hpp @@ -8,6 +8,23 @@ extern "C" { #include #include #include + // Per-family public headers (alphabetical, per the family-block convention): + // family type declarations and cross-family conversions (e.g. + // tcbuffer_to_tfloat, ttext_to_tjsonb, tbigint_to_tquadbin) live here, not in + // the meos.h umbrella. The port builds every family the generated UDFs call + // into (pointcloud is off: it surfaces no type or UDF yet). (Alphabetical also + // keeps meos_pose.h before meos_rgeo.h, which depends on it.) + #include + #include + #include + #include + #include + #include + #include + // PG-compat date/timestamp arithmetic (add_date_int, add_timestamptz_interval) + // lives in the pgtypes public leaf headers, not the meos.h umbrella. + #include + #include } // Create explicit aliases for MEOS types diff --git a/src/include/mobilityduck/bindings.hpp b/src/include/mobilityduck/bindings.hpp index cdac2a3a..9b83d274 100644 --- a/src/include/mobilityduck/bindings.hpp +++ b/src/include/mobilityduck/bindings.hpp @@ -155,9 +155,9 @@ MakeTemporalDatumAccessor(uintptr_t (*meos_fn)(const Temporal *), // by name + (input temporal type, output LogicalType), wiring in the // generated executor built from `meos_fn`. // -// Example (TBOOL): +// Example (tbool): // RegisterTemporalDatumAccessor( -// loader, "startValue", TemporalTypes::TBOOL(), +// loader, "startValue", TemporalTypes::tbool(), // duckdb::LogicalType::BOOLEAN, temporal_start_value); // --------------------------------------------------------------------- diff --git a/src/include/mobilityduck/meos_exec_serial.hpp b/src/include/mobilityduck/meos_exec_serial.hpp index 5e3ba782..f26eb7bb 100644 --- a/src/include/mobilityduck/meos_exec_serial.hpp +++ b/src/include/mobilityduck/meos_exec_serial.hpp @@ -2,9 +2,12 @@ #include +#include "duckdb/function/cast/default_casts.hpp" #include "duckdb/function/scalar_function.hpp" #include "duckdb/main/extension/extension_loader.hpp" +#include "mobilityduck/meos_thread.hpp" + namespace duckdb { /** @@ -26,6 +29,10 @@ inline ScalarFunction WrapScalarFunctionWithMeosExecMutex(ScalarFunction sf) { scalar_function_t orig = std::move(sf.function); sf.function = [orig = std::move(orig)](DataChunk &args, ExpressionState &state, Vector &result) { std::lock_guard guard(MeosSerializedExecMutex()); + // DuckDB runs scalar/cast/aggregate bodies on worker threads whose MEOS + // thread-local state (timezone/locale/PROJ/RNG) is uninitialised; init once + // per thread before any MEOS call (see meos_thread.hpp). + EnsureMeosThreadInitialized(); orig(args, state, result); }; return sf; @@ -35,4 +42,33 @@ inline void RegisterSerializedScalarFunction(ExtensionLoader &loader, ScalarFunc loader.RegisterFunction(WrapScalarFunctionWithMeosExecMutex(std::move(sf))); } +/** + * Cast functions are a separate registration path from scalar functions and + * have no shared execution wrapper, yet they call MEOS just the same (e.g. the + * VARCHAR -> tgeompoint parse). The original function pointer is stashed in + * the bound cast data and reached through a trampoline that runs the + * per-thread MEOS init before delegating. MobilityDuck cast functions do not + * use cast_data themselves, so forwarding it untouched is safe. + */ +struct MeosCastData : BoundCastData { + explicit MeosCastData(cast_function_t orig_p) : orig(orig_p) { + } + cast_function_t orig; + unique_ptr Copy() const override { + return make_uniq(orig); + } +}; + +inline bool MeosCastTrampoline(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { + EnsureMeosThreadInitialized(); + auto &data = parameters.cast_data->Cast(); + return data.orig(source, result, count, parameters); +} + +inline void RegisterMeosCastFunction(ExtensionLoader &loader, const LogicalType &source, const LogicalType &target, + cast_function_t function, int64_t implicit_cast_cost = -1) { + loader.RegisterCastFunction(source, target, BoundCastInfo(MeosCastTrampoline, make_uniq(function)), + implicit_cast_cost); +} + } // namespace duckdb diff --git a/src/include/mobilityduck/meos_thread.hpp b/src/include/mobilityduck/meos_thread.hpp new file mode 100644 index 00000000..e23eef3d --- /dev/null +++ b/src/include/mobilityduck/meos_thread.hpp @@ -0,0 +1,34 @@ +#pragma once + +extern "C" { +#include +} + +// Defined in mobilityduck_extension.cpp. Converts MEOS errors into DuckDB +// exceptions instead of the process-exiting default handler. +extern "C" void MobilityduckMeosErrorHandler(int errlevel, int errcode, const char *errmsg); + +namespace duckdb { + +// MEOS keeps the session timezone, errno, PROJ context and the RNGs in +// thread-local storage; each thread that calls MEOS must initialise it +// before its first call (see meos.h, "Multithreading"). DuckDB runs +// scalar, cast and aggregate bodies on TaskScheduler worker threads, so a +// one-shot init on the load thread leaves workers with a NULL +// session_timezone and pg_next_dst_boundary segfaults on the first +// timestamp parse. This runs the per-thread init exactly once per thread. +// +// meos_initialize() resets the process-global error handler to the +// exit-on-error default, so MobilityduckMeosErrorHandler is re-installed +// here; the store is an idempotent atomic write of the same pointer. +inline void EnsureMeosThreadInitialized() { + static thread_local const bool meos_thread_ready = []() { + meos_initialize(); + meos_initialize_error_handler(&MobilityduckMeosErrorHandler); + meos_initialize_timezone("Europe/Brussels"); + return true; + }(); + (void) meos_thread_ready; +} + +} // namespace duckdb diff --git a/src/include/quadbin/tquadbin.hpp b/src/include/quadbin/tquadbin.hpp new file mode 100644 index 00000000..27f41822 --- /dev/null +++ b/src/include/quadbin/tquadbin.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include "meos_wrapper_simple.hpp" +#include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include + +namespace duckdb { + +/* QUADBIN is a 64-bit unsigned cell id (CARTO QUADBIN square-quadtree DGGS); + * surfaced as BIGINT (signed reinterpretation is safe — equality and ordering + * care only about the bit pattern). TQUADBIN is the temporal cell index, + * stored as a Temporal* blob (BLOB). Analogue of H3INDEX / TH3INDEX. */ +struct QuadbinTypes { + static LogicalType QUADBIN(); + static LogicalType TQUADBIN(); + + static void RegisterTypes(ExtensionLoader &loader); + static void RegisterCastFunctions(ExtensionLoader &loader); + static void RegisterScalarFunctions(ExtensionLoader &loader); +}; + +struct QuadbinFunctions { + /* In/out — static QUADBIN cell (BIGINT) */ + static bool Quadbin_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool Quadbin_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + + /* In/out — TQUADBIN temporal value */ + static bool Tquadbin_in_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + static bool Tquadbin_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + + /* Static cell helpers */ + static void Quadbin_tile_to_cell(DataChunk &args, ExpressionState &state, Vector &result); + static void Quadbin_cell_to_tile_x(DataChunk &args, ExpressionState &state, Vector &result); + static void Quadbin_cell_to_tile_y(DataChunk &args, ExpressionState &state, Vector &result); + static void Quadbin_cell_to_tile_z(DataChunk &args, ExpressionState &state, Vector &result); + static void Quadbin_get_resolution(DataChunk &args, ExpressionState &state, Vector &result); + static void Quadbin_is_valid_cell(DataChunk &args, ExpressionState &state, Vector &result); + + /* Constructor */ + static void Tquadbin_make(DataChunk &args, ExpressionState &state, Vector &result); + + /* Accessors */ + static void Tquadbin_start_value(DataChunk &args, ExpressionState &state, Vector &result); + static void Tquadbin_end_value(DataChunk &args, ExpressionState &state, Vector &result); + static void Tquadbin_value_n(DataChunk &args, ExpressionState &state, Vector &result); + static void Tquadbin_values(DataChunk &args, ExpressionState &state, Vector &result); + static void Tquadbin_value_at_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); + + /* Quadkey conversion */ + static void Tquadbin_cell_to_quadkey(DataChunk &args, ExpressionState &state, Vector &result); + + /* Casts to/from tbigint */ + static void Tbigint_to_tquadbin(DataChunk &args, ExpressionState &state, Vector &result); + static void Tquadbin_to_tbigint(DataChunk &args, ExpressionState &state, Vector &result); +}; + +} // namespace duckdb diff --git a/src/include/single_tile_getters.hpp b/src/include/single_tile_getters.hpp index c704dfcc..77e693c1 100644 --- a/src/include/single_tile_getters.hpp +++ b/src/include/single_tile_getters.hpp @@ -8,7 +8,7 @@ namespace duckdb { // grid configuration (size + origin), return the single tile/box that // contains the input. // -// These complement the LIST/LIST emitters (`valueTiles`, +// These complement the LIST/LIST emitters (`valueTiles`, // `timeTiles`, `valueTimeTiles`, `spaceTiles`, ...) by exposing the // per-input lookup form that MobilityDB ships at the SQL surface. struct SingleTileGetters { diff --git a/src/include/temporal/set.hpp b/src/include/temporal/set.hpp index ed4b21d0..e7522955 100644 --- a/src/include/temporal/set.hpp +++ b/src/include/temporal/set.hpp @@ -34,7 +34,7 @@ struct SetTypes { }; struct SetTypeMapping { - static meosType GetMeosTypeFromAlias(const std::string &alias); + static MeosType GetMeosTypeFromAlias(const std::string &alias); static LogicalType GetChildType(const LogicalType &type); }; diff --git a/src/include/temporal/set_functions.hpp b/src/include/temporal/set_functions.hpp index 9513fe1a..3182e020 100644 --- a/src/include/temporal/set_functions.hpp +++ b/src/include/temporal/set_functions.hpp @@ -45,18 +45,14 @@ struct SetFunctions { static void Set_start_value(DataChunk &args, ExpressionState &state, Vector &result); static void Set_end_value(DataChunk &args, ExpressionState &state, Vector &result); static void Set_value_n(DataChunk &args, ExpressionState &state, Vector &result_vec); - static void Set_values(DataChunk &args, ExpressionState &state, Vector &result); + // Set_values retired: getValues() is generated (set_values) in generated_temporal_udfs.cpp. static void Numset_shift(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzset_shift(DataChunk &args, ExpressionState &state, Vector &result); static void Numset_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzset_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Numset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatset_floor(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatset_ceil(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatset_round(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatset_degrees(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatset_radians(DataChunk &args, ExpressionState &state, Vector &result); + // floor/ceil/round/degrees/radians on floatset are generated (generated_temporal_udfs.cpp). static void Textset_lower(DataChunk &args, ExpressionState &state, Vector &result); static void Textset_upper(DataChunk &args, ExpressionState &state, Vector &result); static void Textset_initcap(DataChunk &args, ExpressionState &state, Vector &result); diff --git a/src/include/temporal/span.hpp b/src/include/temporal/span.hpp index 3d137e86..5f794e05 100644 --- a/src/include/temporal/span.hpp +++ b/src/include/temporal/span.hpp @@ -17,12 +17,11 @@ namespace duckdb { struct SpanTypes { static const std::vector &AllTypes(); - static LogicalType INTSPAN(); - static LogicalType BIGINTSPAN(); - static LogicalType FLOATSPAN(); - static LogicalType TEXTSPAN(); - static LogicalType DATESPAN(); - static LogicalType TSTZSPAN(); + static LogicalType intspan(); + static LogicalType bigintspan(); + static LogicalType floatspan(); + static LogicalType datespan(); + static LogicalType tstzspan(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); @@ -30,7 +29,7 @@ struct SpanTypes { struct SpanTypeMapping { - static meosType GetMeosTypeFromAlias(const std::string &alias); + static MeosType GetMeosTypeFromAlias(const std::string &alias); static LogicalType GetChildType(const LogicalType &type); }; diff --git a/src/include/temporal/span_functions.hpp b/src/include/temporal/span_functions.hpp index 4a8d51b4..63da4df4 100644 --- a/src/include/temporal/span_functions.hpp +++ b/src/include/temporal/span_functions.hpp @@ -41,7 +41,6 @@ struct SpanFunctions { static void Datespan_to_tstzspan(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzspan_to_datespan(DataChunk &args, ExpressionState &state, Vector &result); static void Set_to_span(DataChunk &args, ExpressionState &state, Vector &result); - static void Set_spans(DataChunk &args, ExpressionState &state, Vector &result); static void Set_split_n_spans(DataChunk &args, ExpressionState &state, Vector &result); static void Set_split_each_n_spans(DataChunk &args, ExpressionState &state, Vector &result); // TODO (Type Range): static void Range_to_span(DataChunk &args, ExpressionState &state, Vector &result); @@ -65,12 +64,9 @@ struct SpanFunctions { static void Tstzspan_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Numspan_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzspan_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspan_floor(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspan_ceil(DataChunk &args, ExpressionState &state, Vector &result); + // floor/ceil/round/degrees/radians on floatspan are generated (generated_temporal_udfs.cpp); + // only round(DOUBLE), the scalar base helper, remains hand-written. static void Float_round(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspan_round(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspan_degrees(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspan_radians(DataChunk &args, ExpressionState &state, Vector &result); // TODO: Selectivity functions // Comparison operators static void Span_eq(DataChunk &args, ExpressionState &state, Vector &result); diff --git a/src/include/temporal/spanset.hpp b/src/include/temporal/spanset.hpp index a47db553..a2768b45 100644 --- a/src/include/temporal/spanset.hpp +++ b/src/include/temporal/spanset.hpp @@ -18,7 +18,6 @@ struct SpansetTypes { static LogicalType intspanset(); static LogicalType bigintspanset(); static LogicalType floatspanset(); - static LogicalType textspanset(); static LogicalType datespanset(); static LogicalType tstzspanset(); @@ -31,7 +30,7 @@ struct SpansetTypes { }; struct SpansetTypeMapping { - static meosType GetMeosTypeFromAlias(const std::string &alias); + static MeosType GetMeosTypeFromAlias(const std::string &alias); static LogicalType GetChildType(const LogicalType &type); static LogicalType GetBaseType(const LogicalType &type); static LogicalType GetSetType(const LogicalType &type); diff --git a/src/include/temporal/spanset_functions.hpp b/src/include/temporal/spanset_functions.hpp index 62ae53e1..ec210fc9 100644 --- a/src/include/temporal/spanset_functions.hpp +++ b/src/include/temporal/spanset_functions.hpp @@ -78,12 +78,7 @@ struct SpansetFunctions{ static void Tstzspanset_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Numspanset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); static void Tstzspanset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspanset_floor(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspanset_ceil(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspanset_round(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspanset_degrees(DataChunk &args, ExpressionState &state, Vector &result); - static void Floatspanset_radians(DataChunk &args, ExpressionState &state, Vector &result); - static void Spanset_spans(DataChunk &args, ExpressionState &state, Vector &result); + // floor/ceil/round/degrees/radians on floatspanset are generated (generated_temporal_udfs.cpp). static void Spanset_split_n_spans(DataChunk &args, ExpressionState &state, Vector &result); static void Spanset_split_each_n_spans(DataChunk &args, ExpressionState &state, Vector &result); diff --git a/src/include/temporal/tbox.hpp b/src/include/temporal/tbox.hpp index 9cefb6ff..3d1133f1 100644 --- a/src/include/temporal/tbox.hpp +++ b/src/include/temporal/tbox.hpp @@ -13,7 +13,7 @@ namespace duckdb { class ExtensionLoader; struct TboxType { - static LogicalType TBOX(); + static LogicalType tbox(); static void RegisterType(ExtensionLoader &loader); static void RegisterCastFunctions(ExtensionLoader &loader); diff --git a/src/include/temporal/tbox_functions.hpp b/src/include/temporal/tbox_functions.hpp index 9bebb560..f03f69cd 100644 --- a/src/include/temporal/tbox_functions.hpp +++ b/src/include/temporal/tbox_functions.hpp @@ -17,7 +17,7 @@ class ExtensionLoader; struct TboxFunctions { /* *************************************************** - * In/out functions: VARCHAR <-> TBOX + * In/out functions: VARCHAR <-> tbox ****************************************************/ static bool Tbox_in(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static bool Tbox_out(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); @@ -26,22 +26,22 @@ struct TboxFunctions { * Constructor functions ****************************************************/ template - static void NumberTimestamptzToTboxExecutor(Vector &value, Vector &t, meosType basetype, Vector &result, idx_t count); + static void NumberTimestamptzToTboxExecutor(Vector &value, Vector &t, MeosType basetype, Vector &result, idx_t count); static void Number_timestamptz_to_tbox(DataChunk &args, ExpressionState &state, Vector &result); static void Numspan_timestamptz_to_tbox(DataChunk &args, ExpressionState &state, Vector &result); template - static void NumberTstzspanToTboxExecutor(Vector &value, Vector &span_str, meosType basetype, Vector &result, idx_t count); + static void NumberTstzspanToTboxExecutor(Vector &value, Vector &span_str, MeosType basetype, Vector &result, idx_t count); static void Number_tstzspan_to_tbox(DataChunk &args, ExpressionState &state, Vector &result);; static void Numspan_tstzspan_to_tbox(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** - * Conversion functions + cast functions: [TYPE] -> TBOX + * Conversion functions + cast functions: [TYPE] -> tbox ****************************************************/ template - static void NumberToTboxExecutor(Vector &value, meosType basetype, Vector &result, idx_t count); + static void NumberToTboxExecutor(Vector &value, MeosType basetype, Vector &result, idx_t count); static void Number_to_tbox(DataChunk &args, ExpressionState &state, Vector &result); static bool Number_to_tbox_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); @@ -64,7 +64,7 @@ struct TboxFunctions { static void Spanset_to_tbox(DataChunk &args, ExpressionState &state, Vector &result); static bool Spanset_to_tbox_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); /* *************************************************** - * Conversion functions + cast functions: TBOX -> [TYPE] + * Conversion functions + cast functions: tbox -> [TYPE] ****************************************************/ static void TboxToIntspanExecutor(Vector &value, Vector &result, idx_t count); static void Tbox_to_intspan(DataChunk &args, ExpressionState &state, Vector &result); @@ -115,7 +115,7 @@ struct TboxFunctions { static void Tbox_shift_scale_time(DataChunk &args, ExpressionState &state, Vector &result); template - static void TboxExpandValueExecutor(Vector &tbox, Vector &value, meosType basetype, Vector &result, idx_t count); + static void TboxExpandValueExecutor(Vector &tbox, Vector &value, MeosType basetype, Vector &result, idx_t count); static void Tbox_expand_value(DataChunk &args, ExpressionState &state, Vector &result); static void Tbox_expand_time(DataChunk &args, ExpressionState &state, Vector &result); diff --git a/src/include/temporal/temporal.hpp b/src/include/temporal/temporal.hpp index dcd41aa3..4b336706 100644 --- a/src/include/temporal/temporal.hpp +++ b/src/include/temporal/temporal.hpp @@ -22,17 +22,19 @@ typedef struct { } basetype_struct; static const basetype_struct BASE_TYPES[] = { - {"TINT", LogicalType::BIGINT}, - {"TBOOL", LogicalType::BOOLEAN}, - {"TFLOAT", LogicalType::DOUBLE}, - {"TTEXT", LogicalType::VARCHAR} + {"tint", LogicalType::BIGINT}, + {"tbigint", LogicalType::BIGINT}, + {"tbool", LogicalType::BOOLEAN}, + {"tfloat", LogicalType::DOUBLE}, + {"ttext", LogicalType::VARCHAR} }; struct TemporalTypes { - static LogicalType TINT(); - static LogicalType TBOOL(); - static LogicalType TFLOAT(); - static LogicalType TTEXT(); + static LogicalType tint(); + static LogicalType tbigint(); + static LogicalType tbool(); + static LogicalType tfloat(); + static LogicalType ttext(); static const std::vector &AllTypes(); static LogicalType GetBaseTypeFromAlias(const char *alias); @@ -45,7 +47,6 @@ struct TemporalTypes { static void RegisterTemporalTileSplit(ExtensionLoader &loader); static void RegisterTileGetters(ExtensionLoader &loader); static void RegisterTnumberValueSplit(ExtensionLoader &loader); - static void RegisterSimilarityPath(ExtensionLoader &loader); }; } // namespace duckdb diff --git a/src/include/temporal/temporal_functions.hpp b/src/include/temporal/temporal_functions.hpp index 5da7fda4..2bf427bd 100644 --- a/src/include/temporal/temporal_functions.hpp +++ b/src/include/temporal/temporal_functions.hpp @@ -14,11 +14,11 @@ class ExtensionLoader; typedef struct { char *alias; - meosType temptype; + MeosType temptype; } alias_type_struct; struct TemporalHelpers { - static meosType GetTemptypeFromAlias(const char *alias); + static MeosType GetTemptypeFromAlias(const char *alias); static vector TempArrToArray(Temporal **temparr, int32_t count, LogicalType element_type); }; @@ -89,7 +89,7 @@ struct TemporalFunctions { static void Temporal_sequences(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_start_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_end_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); - static void Temporal_timestamps(DataChunk &args, ExpressionState &state, Vector &result); + // Temporal_timestamps retired: timestamps() is generated (temporal_timestamps) in generated_temporal_udfs.cpp. static void Temporal_instants(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_num_sequences(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_lower_inc(DataChunk &args, ExpressionState &state, Vector &result); @@ -140,8 +140,6 @@ struct TemporalFunctions { static void Temporal_minus_min(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_at_max(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_minus_max(DataChunk &args, ExpressionState &state, Vector &result); - static void Tnumber_at_tbox(DataChunk &args, ExpressionState &state, Vector &result); - static void Tnumber_minus_tbox(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_at_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_minus_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_value_at_timestamptz(DataChunk &args, ExpressionState &state, Vector &result); @@ -224,7 +222,7 @@ struct TemporalFunctions { * Unary tnumber functions ****************************************************/ static void Tnumber_abs(DataChunk &args, ExpressionState &state, Vector &result); - static void Tnumber_tboxes(DataChunk &args, ExpressionState &state, Vector &result); + // Tnumber_tboxes retired: tboxes() is generated (tnumber_tboxes) in generated_temporal_udfs.cpp. static void Tnumber_split_n_tboxes(DataChunk &args, ExpressionState &state, Vector &result); static void Tnumber_split_each_n_tboxes(DataChunk &args, ExpressionState &state, Vector &result); static void Tnumber_delta_value(DataChunk &args, ExpressionState &state, Vector &result); @@ -233,8 +231,7 @@ struct TemporalFunctions { static void Tfloat_ln(DataChunk &args, ExpressionState &state, Vector &result); static void Tfloat_log10(DataChunk &args, ExpressionState &state, Vector &result); // Temporal_derivative declared in the math-functions block below. - static void Tfloat_degrees(DataChunk &args, ExpressionState &state, Vector &result); - static void Tfloat_radians(DataChunk &args, ExpressionState &state, Vector &result); + // floor/ceil/round/degrees/radians on tfloat are generated (generated_temporal_udfs.cpp). /* *************************************************** * Temporal comparison predicates returning Temporal @@ -413,8 +410,6 @@ struct TemporalFunctions { static void Temporal_frechet_distance(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_dyntimewarp_distance(DataChunk &args, ExpressionState &state, Vector &result); static void Temporal_hausdorff_distance(DataChunk &args, ExpressionState &state, Vector &result); - static void Temporal_frechet_path(DataChunk &args, ExpressionState &state, Vector &result); - static void Temporal_dyntimewarp_path(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** * tnumber × {numspan, tbox} topological predicates @@ -551,13 +546,13 @@ struct TemporalFunctions { * Workaround functions ****************************************************/ template - static void Temporal_dump_common(DataChunk &args, Vector &result, meosType basetype); + static void Temporal_dump_common(DataChunk &args, Vector &result, MeosType basetype); static void Temporal_dump(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** * Math functions ****************************************************/ - static void Temporal_round(DataChunk &args, ExpressionState &state, Vector &result); + // round(tfloat/tgeompoint/tgeogpoint/...) is generated (generated_temporal_udfs.cpp). static void Temporal_derivative(DataChunk &args, ExpressionState &state, Vector &result); /* *************************************************** diff --git a/src/include/tydef.hpp b/src/include/tydef.hpp index b9860ca0..9b85b431 100644 --- a/src/include/tydef.hpp +++ b/src/include/tydef.hpp @@ -11,28 +11,6 @@ extern "C" { #include } -// MEOS naming history: `meosType` is the **pre-consolidation** spelling -// and `MeosType` is the **post-consolidation** target (the rename is -// part of the upstream consolidation sweep, not yet reached by the -// vcpkg pin). The current pin -// (`vcpkg_ports/meos/portfile.cmake` REF f11b7443ee98…) is still -// pre-consolidation and exposes `meosType` — see -// meos/include/temporal/meos_catalog.h, where line 121 declares -// `} meosType;`. MobilityDuck's source consistently uses -// `meosType` (verified via `grep -rn '\bmeosType\b' src/`), which -// matches the pin, so no alias is needed today. -// -// An earlier version of this file added `using meosType = MeosType;` -// as a forward-looking bridge for the eventual consolidation bump. -// That alias references `MeosType`, which the current pin does NOT -// yet expose, so it broke the build: -// "'MeosType' does not name a type; did you mean 'meosType'?". -// -// When the MEOS pin is bumped past the consolidation point, restore -// a bridge here (`using meosType = MeosType;` becomes valid then) or -// sweep the source `meosType → MeosType` in one PR — whichever the -// project prefers at that time. - namespace duckdb { static inline Datum diff --git a/src/index/rtree_index_scan.cpp b/src/index/rtree_index_scan.cpp index 623fc5d1..1f7c165d 100644 --- a/src/index/rtree_index_scan.cpp +++ b/src/index/rtree_index_scan.cpp @@ -58,7 +58,7 @@ static unique_ptr RTreeIndexScanInitGlobal(ClientConte result->local_storage_state.Initialize(result->column_ids, context, input.filters); local_storage.InitializeScan(bind_data.table.GetStorage(), result->local_storage_state.local_state, input.filters); - // Initialize index scan - works for both STBOX and TSTZSPAN + // Initialize index scan - works for both stbox and tstzspan if (bind_data.query_box) { result->index_state = bind_data.index.Cast().InitializeScan( bind_data.query_box.get(), diff --git a/src/index/rtree_module.cpp b/src/index/rtree_module.cpp index d05e4be8..bbc834f3 100644 --- a/src/index/rtree_module.cpp +++ b/src/index/rtree_module.cpp @@ -49,16 +49,16 @@ TRTreeIndex::TRTreeIndex(const string &name, IndexConstraintType constraint_type auto &type = unbound_expressions[0]->return_type; - if (type == StboxType::STBOX()) { + if (type == StboxType::stbox()) { bbox_type_ = T_STBOX; bbox_size_ = sizeof(STBox); rtree_ = rtree_create_stbox(); - } else if (type == SpanTypes::TSTZSPAN()) { + } else if (type == SpanTypes::tstzspan()) { bbox_type_ = T_TSTZSPAN; bbox_size_ = sizeof(Span); rtree_ = rtree_create_tstzspan(); } else { - throw InternalException("RTree index only supports STBOX and TSTZSPAN types, got: " + type.ToString()); + throw InternalException("RTree index only supports stbox and tstzspan types, got: " + type.ToString()); } if (!rtree_) { @@ -393,25 +393,22 @@ vector TRTreeIndex::Search(const void *query_box, RTreeSearchOp op) const return results; } - int count = 0; - int *ids = nullptr; - + MeosArray *ids = meos_array_create(sizeof(int)); + try { - ids = rtree_search(rtree_, op, query_box, &count); - - if (ids && count > 0) { + int count = rtree_search(rtree_, op, query_box, ids); + + if (count > 0) { results.reserve(count); for (int i = 0; i < count; i++) { - results.push_back(static_cast(ids[i])); + results.push_back(static_cast(*(int *) meos_array_get(ids, i))); } } } catch (...) { fprintf(stderr, "Exception during rtree_search\n"); } - - if (ids) { - free(ids); - } + + meos_array_destroy(ids); return results; } @@ -478,9 +475,9 @@ unique_ptr TRTreeIndex::MakeFunctionMatcher() const { LogicalType index_type; if (bbox_type_ == T_STBOX) { - index_type = StboxType::STBOX(); + index_type = StboxType::stbox(); } else if (bbox_type_ == T_TSTZSPAN) { - index_type = SpanTypes::TSTZSPAN(); + index_type = SpanTypes::tstzspan(); } else { index_type = LogicalType::BLOB; } diff --git a/src/mobilityduck_extension.cpp b/src/mobilityduck_extension.cpp index fddcf43a..67418aee 100644 --- a/src/mobilityduck_extension.cpp +++ b/src/mobilityduck_extension.cpp @@ -1,5 +1,6 @@ #define DUCKDB_EXTENSION_MAIN +#include #include "mobilityduck_extension.hpp" #include "temporal/spanset.hpp" #include "temporal/set.hpp" @@ -17,6 +18,8 @@ #include "geo/tgeography_ops.hpp" #include "geo/tgeogpoint.hpp" #include "geo/tgeogpoint_ops.hpp" +#include "quadbin/tquadbin.hpp" +#include "cbuffer/tcbuffer.hpp" #include "temporal/span.hpp" #include "temporal/span_aggregates.hpp" #include "temporal/temporal_aggregates.hpp" @@ -82,7 +85,7 @@ inline void MobilityduckOpenSSLVersionScalarFun(DataChunk &args, ExpressionState // MEOS does not expose a runtime version symbol, so the build-time pin // is the most precise version stamp the extension can report. #ifndef MOBILITYDUCK_MEOS_PIN -#define MOBILITYDUCK_MEOS_PIN "f11b7443e" +#define MOBILITYDUCK_MEOS_PIN "88e5d5b430" #endif inline std::string MobilityduckShortVersion() { @@ -209,6 +212,9 @@ extern "C" void MobilityduckMeosErrorHandler(int errlevel, int errcode, const ch // 5. Extension load logic // ===================================================================== +// Defined in the catalog-generated src/generated/generated_temporal_udfs.cpp. +void RegisterGeneratedTemporalUdfs(ExtensionLoader &loader); + static void LoadInternal(ExtensionLoader &loader) { // Configure MEOS SRID CSV once (env / embedded) ConfigureMeosSridCsvOnce(); @@ -228,12 +234,26 @@ static void LoadInternal(ExtensionLoader &loader) { // Single-timezone model: ensure DuckDB's session timezone matches the // MEOS timezone so bare TIMESTAMPTZ display agrees with MEOS composite - // type strings. Auto-load ICU (without it, the test framework keeps - // session timezone at UTC) and set the TimeZone option to Brussels. + // type strings. This needs ICU for the named "Europe/Brussels" zone. + // + // If ICU cannot be auto-loaded (no on-disk copy AND no network egress: + // CI docker images, edge/musl deployments, offline installs), degrade + // gracefully to the session default (UTC) instead of failing the whole + // extension load. Tests that assert Brussels display stage ICU locally + // via the Makefile's stage_icu. auto &db = loader.GetDatabaseInstance(); - ExtensionHelper::AutoLoadExtension(db, "icu"); - auto &config = DBConfig::GetConfig(db); - config.SetOptionByName("TimeZone", Value("Europe/Brussels")); + try { + ExtensionHelper::AutoLoadExtension(db, "icu"); + auto &config = DBConfig::GetConfig(db); + config.SetOptionByName("TimeZone", Value("Europe/Brussels")); + } catch (const std::exception &e) { + // ICU unavailable: leave the session timezone at its default. + // Temporal-type text I/O is unaffected; only bare TIMESTAMPTZ display + // falls back to UTC. + fprintf(stderr, + "mobilityduck: ICU not available (%s); session timezone left " + "at default instead of Europe/Brussels.\n", e.what()); + } // Register scalar function: mobilityduck_openssl_version @@ -269,7 +289,6 @@ static void LoadInternal(ExtensionLoader &loader) { TemporalTypes::RegisterWkbFunctions(loader); TemporalTypes::RegisterTemporalTileSplit(loader); TemporalTypes::RegisterTnumberValueSplit(loader); - TemporalTypes::RegisterSimilarityPath(loader); TboxType::RegisterType(loader); TboxType::RegisterCastFunctions(loader); @@ -285,7 +304,7 @@ static void LoadInternal(ExtensionLoader &loader) { SpanAggregates::RegisterAggregateFunctions(loader); TemporalAggregates::RegisterAggregateFunctions(loader); - // Tile getters return SpanTypes blobs and consume TBOX, so all those + // Tile getters return SpanTypes blobs and consume tbox, so all those // types must already be registered. TemporalTypes::RegisterTileGetters(loader); @@ -327,6 +346,13 @@ static void LoadInternal(ExtensionLoader &loader) { SpatialSetType::RegisterCastFunctions(loader); SpatialSetType::RegisterScalarFunctions(loader); + QuadbinTypes::RegisterTypes(loader); + QuadbinTypes::RegisterCastFunctions(loader); + QuadbinTypes::RegisterScalarFunctions(loader); + + CbufferTypes::RegisterTypes(loader); + CbufferTypes::RegisterCastFunctions(loader); + SpansetTypes::RegisterTypes(loader); SpansetTypes::RegisterCastFunctions(loader); SpansetTypes::RegisterScalarFunctions(loader); @@ -335,10 +361,13 @@ static void LoadInternal(ExtensionLoader &loader) { TRTreeModule::RegisterIndexScan(loader); TRTreeModule::RegisterScanOptimizer(loader); - // Single-tile getters depend on TBOX, STBOX, and the spatial GEOMETRY + // Single-tile getters depend on tbox, stbox, and the spatial GEOMETRY // type being registered first. SingleTileGetters::RegisterScalarFunctions(loader); + // Catalog-driven scalar UDFs generated from the MEOS-API catalog, organized by + // doxygen @ingroup group. Registered last, after every type accessor exists. + RegisterGeneratedTemporalUdfs(loader); // TemporalParquet footer helper for COPY ... TO '*.parquet' KV_METADATA. TemporalParquetFunctions::Register(loader); } diff --git a/src/quadbin/tquadbin.cpp b/src/quadbin/tquadbin.cpp new file mode 100644 index 00000000..fdcbdae7 --- /dev/null +++ b/src/quadbin/tquadbin.cpp @@ -0,0 +1,456 @@ +/* MobilityDuck binding for the MEOS QUADBIN cell index types (quadbin + + * tquadbin). Wraps every implemented export from `meos_quadbin.h` so DuckDB + * SQL can call the full static-cell and temporal-cell surface. + * + * QUADBIN is surfaced as BIGINT (the 64-bit cell id reinterprets losslessly). + * TQUADBIN is the temporal cell index, stored as a Temporal* blob (BLOB). + * The analogue of H3INDEX / TH3INDEX for the square Web-Mercator DGGS. + */ + +#include "quadbin/tquadbin.hpp" +#include "temporal/temporal.hpp" +#include "tydef.hpp" +#include "duckdb/common/types/data_chunk.hpp" +#include "duckdb/main/extension/extension_loader.hpp" +#include "duckdb/common/extension_type_info.hpp" +#include "duckdb/function/scalar_function.hpp" +#include "mobilityduck/meos_exec_serial.hpp" +#include "time_util.hpp" + +extern "C" { + #include + #include + #include +} + +#include +#include +#include +#include + +namespace duckdb { + +LogicalType QuadbinTypes::QUADBIN() { + LogicalType type = LogicalType::BIGINT; + type.SetAlias("QUADBIN"); + return type; +} + +LogicalType QuadbinTypes::TQUADBIN() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("TQUADBIN"); + return type; +} + +void QuadbinTypes::RegisterTypes(ExtensionLoader &loader) { + loader.RegisterType("QUADBIN", QUADBIN()); + loader.RegisterType("TQUADBIN", TQUADBIN()); +} + +void QuadbinTypes::RegisterCastFunctions(ExtensionLoader &loader) { + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, QUADBIN(), + QuadbinFunctions::Quadbin_in_cast); + RegisterMeosCastFunction(loader, QUADBIN(), LogicalType::VARCHAR, + QuadbinFunctions::Quadbin_out_cast); + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, TQUADBIN(), + QuadbinFunctions::Tquadbin_in_cast); + RegisterMeosCastFunction(loader, TQUADBIN(), LogicalType::VARCHAR, + QuadbinFunctions::Tquadbin_out_cast); +} + +namespace { + +inline Temporal *BlobToTemp(string_t blob) { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *) malloc(sz); + memcpy(copy, blob.GetData(), sz); + return reinterpret_cast(copy); +} + +inline string_t TempToBlob(Vector &result, Temporal *t) { + if (!t) return string_t(); + size_t sz = temporal_mem_size(t); + string_t out = StringVector::AddStringOrBlob( + result, string_t(reinterpret_cast(t), sz)); + free(t); + return out; +} + +} // namespace + +/* ===================================================================== + * In / out — static QUADBIN cell (BIGINT) + * + * QUADBIN cells are represented as decimal uint64 integers in CARTO's + * canonical form (e.g. 5193776270265024512). + * ===================================================================== */ + +bool QuadbinFunctions::Quadbin_in_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t s) -> int64_t { + std::string str(s.GetData(), s.GetSize()); + uint64_t v = std::stoull(str); + return static_cast(v); + }); + return true; +} + +bool QuadbinFunctions::Quadbin_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](int64_t v) -> string_t { + std::string s = std::to_string(static_cast(v)); + return StringVector::AddString(result, s); + }); + return true; +} + +/* ===================================================================== + * In / out — TQUADBIN temporal value + * ===================================================================== */ + +bool QuadbinFunctions::Tquadbin_in_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t s) -> string_t { + std::string str(s.GetData(), s.GetSize()); + Temporal *t = tquadbin_in(str.c_str()); + return TempToBlob(result, t); + }); + return true; +} + +bool QuadbinFunctions::Tquadbin_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ + UnaryExecutor::Execute( + source, result, count, + [&](string_t blob) -> string_t { + Temporal *t = BlobToTemp(blob); + char *str = temporal_out(t, OUT_DEFAULT_DECIMAL_DIGITS); + free(t); + std::string copy(str); + free(str); + return StringVector::AddString(result, copy); + }); + return true; +} + +/* ===================================================================== + * Static cell helpers + * ===================================================================== */ + +void QuadbinFunctions::Quadbin_tile_to_cell( + DataChunk &args, ExpressionState &state, Vector &result) +{ + TernaryExecutor::Execute( + args.data[0], args.data[1], args.data[2], result, args.size(), + [](int32_t x, int32_t y, int32_t z) -> int64_t { + Quadbin cell = quadbin_tile_to_cell( + static_cast(x), + static_cast(y), + static_cast(z)); + return static_cast(cell); + }); +} + +/* quadbinCellToTileX/Y/Z: expose each tile coordinate as a separate scalar. + * DuckDB has no STRUCT type in the current MobilityDuck surface; three + * functions mirror the (x,y,z) MobilityDB SQL pattern. */ +void QuadbinFunctions::Quadbin_cell_to_tile_x( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [](int64_t v) -> int32_t { + uint32_t x, y, z; + quadbin_cell_to_tile(static_cast(v), &x, &y, &z); + return static_cast(x); + }); +} + +void QuadbinFunctions::Quadbin_cell_to_tile_y( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [](int64_t v) -> int32_t { + uint32_t x, y, z; + quadbin_cell_to_tile(static_cast(v), &x, &y, &z); + return static_cast(y); + }); +} + +void QuadbinFunctions::Quadbin_cell_to_tile_z( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [](int64_t v) -> int32_t { + uint32_t x, y, z; + quadbin_cell_to_tile(static_cast(v), &x, &y, &z); + return static_cast(z); + }); +} + +void QuadbinFunctions::Quadbin_get_resolution( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [](int64_t v) -> int32_t { + return static_cast( + quadbin_get_resolution(static_cast(v))); + }); +} + +void QuadbinFunctions::Quadbin_is_valid_cell( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [](int64_t v) -> bool { + return quadbin_is_valid_cell(static_cast(v)); + }); +} + +/* ===================================================================== + * Constructor — tquadbininst_make wrapped as `tquadbin(cell, t)` + * ===================================================================== */ + +void QuadbinFunctions::Tquadbin_make( + DataChunk &args, ExpressionState &state, Vector &result) +{ + BinaryExecutor::Execute( + args.data[0], args.data[1], result, args.size(), + [&](int64_t cell, timestamp_tz_t t) -> string_t { + TInstant *inst = tquadbininst_make( + static_cast(cell), ToMeosTimestamp(t)); + return TempToBlob(result, reinterpret_cast(inst)); + }); +} + +/* ===================================================================== + * Accessors + * ===================================================================== */ + +void QuadbinFunctions::Tquadbin_start_value( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t blob) -> int64_t { + Temporal *t = BlobToTemp(blob); + Quadbin v = tquadbin_start_value(t); + free(t); + return static_cast(v); + }); +} + +void QuadbinFunctions::Tquadbin_end_value( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::Execute( + args.data[0], result, args.size(), + [&](string_t blob) -> int64_t { + Temporal *t = BlobToTemp(blob); + Quadbin v = tquadbin_end_value(t); + free(t); + return static_cast(v); + }); +} + +void QuadbinFunctions::Tquadbin_value_n( + DataChunk &args, ExpressionState &state, Vector &result) +{ + BinaryExecutor::ExecuteWithNulls( + args.data[0], args.data[1], result, args.size(), + [&](string_t blob, int32_t n, ValidityMask &mask, idx_t idx) -> int64_t { + Temporal *t = BlobToTemp(blob); + Quadbin v; + bool ok = tquadbin_value_n(t, n, &v); + free(t); + if (!ok) { mask.SetInvalid(idx); return 0; } + return static_cast(v); + }); +} + +void QuadbinFunctions::Tquadbin_values( + DataChunk &args, ExpressionState &state, Vector &result) +{ + /* Quadbin[] → LIST; cell ids returned as signed BIGINT. */ + auto &input = args.data[0]; + input.Flatten(args.size()); + auto in_data = FlatVector::GetData(input); + auto list_entries = FlatVector::GetData(result); + auto &out_validity = FlatVector::Validity(result); + idx_t total = 0; + + for (idx_t row = 0; row < args.size(); row++) { + if (!FlatVector::Validity(input).RowIsValid(row)) { + out_validity.SetInvalid(row); + list_entries[row] = list_entry_t{total, 0}; + continue; + } + Temporal *t = BlobToTemp(in_data[row]); + int n = 0; + Quadbin *vals = tquadbin_values(t, &n); + free(t); + if (!vals || n <= 0) { + if (vals) free(vals); + list_entries[row] = list_entry_t{total, 0}; + continue; + } + ListVector::Reserve(result, total + n); + ListVector::SetListSize(result, total + n); + list_entries[row] = list_entry_t{total, static_cast(n)}; + auto child = FlatVector::GetData(ListVector::GetEntry(result)); + for (int i = 0; i < n; i++) + child[total + i] = static_cast(vals[i]); + total += n; + free(vals); + } +} + +void QuadbinFunctions::Tquadbin_value_at_timestamptz( + DataChunk &args, ExpressionState &state, Vector &result) +{ + BinaryExecutor::ExecuteWithNulls( + args.data[0], args.data[1], result, args.size(), + [&](string_t blob, timestamp_tz_t ts, + ValidityMask &mask, idx_t idx) -> int64_t { + Temporal *t = BlobToTemp(blob); + Quadbin v; + bool ok = tquadbin_value_at_timestamptz( + t, ToMeosTimestamp(ts), true, &v); + free(t); + if (!ok) { mask.SetInvalid(idx); return 0; } + return static_cast(v); + }); +} + +/* ===================================================================== + * Quadkey conversion — tquadbin → tvarchar (base-4 slippy-tile string) + * ===================================================================== */ + +void QuadbinFunctions::Tquadbin_cell_to_quadkey( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::ExecuteWithNulls( + args.data[0], result, args.size(), + [&](string_t blob, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemp(blob); + Temporal *r = tquadbin_cell_to_quadkey(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + char *str = temporal_out(r, OUT_DEFAULT_DECIMAL_DIGITS); + free(r); + std::string copy(str); + free(str); + return StringVector::AddString(result, copy); + }); +} + +/* ===================================================================== + * Casts to/from tbigint + * ===================================================================== */ + +void QuadbinFunctions::Tbigint_to_tquadbin( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::ExecuteWithNulls( + args.data[0], result, args.size(), + [&](string_t blob, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemp(blob); + Temporal *r = tbigint_to_tquadbin(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return TempToBlob(result, r); + }); +} + +void QuadbinFunctions::Tquadbin_to_tbigint( + DataChunk &args, ExpressionState &state, Vector &result) +{ + UnaryExecutor::ExecuteWithNulls( + args.data[0], result, args.size(), + [&](string_t blob, ValidityMask &mask, idx_t idx) -> string_t { + Temporal *t = BlobToTemp(blob); + Temporal *r = tquadbin_to_tbigint(t); + free(t); + if (!r) { mask.SetInvalid(idx); return string_t(); } + return TempToBlob(result, r); + }); +} + +/* ===================================================================== + * Registration + * ===================================================================== */ + +void QuadbinTypes::RegisterScalarFunctions(ExtensionLoader &loader) { + const auto QB = QuadbinTypes::QUADBIN(); + const auto TQB = QuadbinTypes::TQUADBIN(); + const auto I32 = LogicalType::INTEGER; + const auto B = LogicalType::BOOLEAN; + const auto V = LogicalType::VARCHAR; + const auto TS = LogicalType::TIMESTAMP_TZ; + + /* Static cell helpers */ + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinTileToCell", {I32, I32, I32}, QB, + QuadbinFunctions::Quadbin_tile_to_cell)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinCellToTileX", {QB}, I32, + QuadbinFunctions::Quadbin_cell_to_tile_x)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinCellToTileY", {QB}, I32, + QuadbinFunctions::Quadbin_cell_to_tile_y)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinCellToTileZ", {QB}, I32, + QuadbinFunctions::Quadbin_cell_to_tile_z)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinGetResolution", {QB}, I32, + QuadbinFunctions::Quadbin_get_resolution)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "quadbinIsValidCell", {QB}, B, + QuadbinFunctions::Quadbin_is_valid_cell)); + + /* Constructor */ + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "tquadbin", {QB, TS}, TQB, + QuadbinFunctions::Tquadbin_make)); + + /* Accessors */ + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "startValue", {TQB}, QB, + QuadbinFunctions::Tquadbin_start_value)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "endValue", {TQB}, QB, + QuadbinFunctions::Tquadbin_end_value)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "valueN", {TQB, I32}, QB, + QuadbinFunctions::Tquadbin_value_n)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "values", {TQB}, LogicalType::LIST(QB), + QuadbinFunctions::Tquadbin_values)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "valueAtTimestamp", {TQB, TS}, QB, + QuadbinFunctions::Tquadbin_value_at_timestamptz)); + + /* Quadkey conversion */ + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( + "cellToQuadkey", {TQB}, V, + QuadbinFunctions::Tquadbin_cell_to_quadkey)); + + /* tbigint ↔ tquadbin: deferred until TemporalTypes::TBIGINT() is published, + * same as the th3index binding. */ +} + +} // namespace duckdb diff --git a/src/single_tile_getters.cpp b/src/single_tile_getters.cpp index 5e4719fd..85d150ad 100644 --- a/src/single_tile_getters.cpp +++ b/src/single_tile_getters.cpp @@ -365,77 +365,77 @@ void SingleTileGetters::RegisterScalarFunctions(ExtensionLoader &loader) { loader.RegisterFunction(ScalarFunction( "getValueTile", {LogicalType::DOUBLE, LogicalType::DOUBLE}, - TboxType::TBOX(), GetValueTileExec)); + TboxType::tbox(), GetValueTileExec)); loader.RegisterFunction(ScalarFunction( "getValueTile", {LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE}, - TboxType::TBOX(), GetValueTileExec)); + TboxType::tbox(), GetValueTileExec)); loader.RegisterFunction(ScalarFunction( "getTBoxTimeTile", {LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, - TboxType::TBOX(), GetTBoxTimeTileExec)); + TboxType::tbox(), GetTBoxTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getTBoxTimeTile", {LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, - TboxType::TBOX(), GetTBoxTimeTileExec)); + TboxType::tbox(), GetTBoxTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getValueTimeTile", {LogicalType::DOUBLE, LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE, LogicalType::INTERVAL}, - TboxType::TBOX(), GetValueTimeTileExec)); + TboxType::tbox(), GetValueTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getValueTimeTile", {LogicalType::DOUBLE, LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE, LogicalType::INTERVAL, LogicalType::DOUBLE, LogicalType::TIMESTAMP_TZ}, - TboxType::TBOX(), GetValueTimeTileExec)); + TboxType::tbox(), GetValueTimeTileExec)); // ---- stbox getters ---- // 4-arg: full xyz sizes, default sorigin loader.RegisterFunction(ScalarFunction( "getSpaceTile", {geometry, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE}, - StboxType::STBOX(), GetSpaceTileExec)); + StboxType::stbox(), GetSpaceTileExec)); // 5-arg: full xyz sizes + explicit sorigin loader.RegisterFunction(ScalarFunction( "getSpaceTile", {geometry, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, geometry}, - StboxType::STBOX(), GetSpaceTileExec)); + StboxType::stbox(), GetSpaceTileExec)); // 2-arg: uniform xyz, default sorigin loader.RegisterFunction(ScalarFunction( "getSpaceTile", {geometry, LogicalType::DOUBLE}, - StboxType::STBOX(), GetSpaceTileUniformExec)); + StboxType::stbox(), GetSpaceTileUniformExec)); loader.RegisterFunction(ScalarFunction( "getStboxTimeTile", {LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL}, - StboxType::STBOX(), GetStboxTimeTileExec)); + StboxType::stbox(), GetStboxTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getStboxTimeTile", {LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, - StboxType::STBOX(), GetStboxTimeTileExec)); + StboxType::stbox(), GetStboxTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getSpaceTimeTile", {geometry, LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::INTERVAL}, - StboxType::STBOX(), GetSpaceTimeTileExec)); + StboxType::stbox(), GetSpaceTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getSpaceTimeTile", {geometry, LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::INTERVAL, geometry}, - StboxType::STBOX(), GetSpaceTimeTileExec)); + StboxType::stbox(), GetSpaceTimeTileExec)); loader.RegisterFunction(ScalarFunction( "getSpaceTimeTile", {geometry, LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::INTERVAL, geometry, LogicalType::TIMESTAMP_TZ}, - StboxType::STBOX(), GetSpaceTimeTileExec)); + StboxType::stbox(), GetSpaceTimeTileExec)); } } // namespace duckdb diff --git a/src/temporal/set.cpp b/src/temporal/set.cpp index 1858e489..dac416db 100644 --- a/src/temporal/set.cpp +++ b/src/temporal/set.cpp @@ -10,7 +10,6 @@ #include "time_util.hpp" #include "mobilityduck/meos_exec_serial.hpp" - extern "C" { #include "meos.h" #include "meos_internal.h" @@ -23,113 +22,50 @@ extern "C" { namespace duckdb { -#define DEFINE_SET_TYPE(NAME) \ - LogicalType SetTypes::NAME() { \ - auto type = LogicalType(LogicalTypeId::BLOB); \ - type.SetAlias(#NAME); \ - return type; \ - } - -DEFINE_SET_TYPE(intset) -DEFINE_SET_TYPE(bigintset) -DEFINE_SET_TYPE(floatset) -DEFINE_SET_TYPE(textset) -DEFINE_SET_TYPE(dateset) -DEFINE_SET_TYPE(tstzset) - -#undef DEFINE_SET_TYPE - -void SetTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "intset", intset()); - loader.RegisterType( "bigintset", bigintset()); - loader.RegisterType( "floatset", floatset()); - loader.RegisterType( "textset", textset()); - loader.RegisterType( "dateset", dateset()); - loader.RegisterType( "tstzset", tstzset()); -} - -const std::vector &SetTypes::AllTypes() { - static std::vector types = { - intset(), - bigintset(), - floatset(), - textset(), - dateset(), - tstzset() - }; - return types; -} - -meosType SetTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { - static const std::unordered_map alias_to_type = { - {"intset", T_INTSET}, - {"bigintset", T_BIGINTSET}, - {"floatset", T_FLOATSET}, - {"textset", T_TEXTSET}, - {"dateset", T_DATESET}, - {"tstzset", T_TSTZSET} - }; - - auto it = alias_to_type.find(alias); - if (it != alias_to_type.end()) { - return it->second; - } else { - return T_UNKNOWN; - } -} - -LogicalType SetTypeMapping::GetChildType(const LogicalType &type) { - auto alias = type.ToString(); - if (alias == "intset") return LogicalType::INTEGER; - if (alias == "bigintset") return LogicalType::BIGINT; - if (alias == "floatset") return LogicalType::DOUBLE; - if (alias == "textset") return LogicalType::VARCHAR; - if (alias == "dateset") return LogicalType::DATE; - if (alias == "tstzset") return LogicalType::TIMESTAMP_TZ; - throw NotImplementedException("GetChildType: unsupported alias: " + alias); -} - +// Collection type registration (accessors, RegisterTypes, AllTypes, alias->MeosType, +// GetChildType) is generated from the catalog MeosType enum into +// src/generated/generated_type_registration.cpp. -// Register all cast functions +// Register all cast functions void SetTypes::RegisterCastFunctions(ExtensionLoader &loader) { for (const auto &set_type : SetTypes::AllTypes()) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, set_type, LogicalType::VARCHAR, SetFunctions::Set_to_text ); // Blob to text - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, set_type, SetFunctions::Text_to_set ); // text to blob auto base_type = SetTypeMapping::GetChildType(set_type); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, base_type, set_type, SetFunctions::Value_to_set_cast // set from base type ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::intset(), SetTypes::floatset(), SetFunctions::Intset_to_floatset_cast // intset -> floatset ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::floatset(), SetTypes::intset(), SetFunctions::Floatset_to_intset_cast // floatset --> intset ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::dateset(), SetTypes::tstzset(), SetFunctions::Dateset_to_tstzset_cast // dateset -> tstzset ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::tstzset(), SetTypes::dateset(), SetFunctions::Tstzset_to_dateset_cast // tstz -> dateset @@ -209,11 +145,9 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction("valueN", {set_type, LogicalType::INTEGER}, base_type, SetFunctions::Set_value_n) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("getValues", {set_type}, LogicalType::LIST(base_type), SetFunctions::Set_values) - ); + // getValues() is generated from the catalog (set_values) in generated_temporal_udfs.cpp. - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {SetTypes::intset(), LogicalType::INTEGER}, SetTypes::intset(), SetFunctions::Numset_shift) ); @@ -275,35 +209,13 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction("shiftScale", {SetTypes::tstzset(), LogicalType::INTERVAL, LogicalType::INTERVAL}, SetTypes::tstzset(), SetFunctions::Tstzset_shift_scale) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("floor", {SetTypes::floatset()}, SetTypes::floatset(), SetFunctions::Floatset_floor) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("ceil", {SetTypes::floatset()}, SetTypes::floatset(), SetFunctions::Floatset_ceil) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("round", {SetTypes::floatset()}, SetTypes::floatset(), SetFunctions::Floatset_round) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("round", {SetTypes::floatset(), LogicalType::INTEGER}, SetTypes::floatset(), SetFunctions::Floatset_round) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("degrees", {SetTypes::floatset()}, SetTypes::floatset(), SetFunctions::Floatset_degrees) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("degrees", {SetTypes::floatset(), LogicalType::BOOLEAN}, SetTypes::floatset(), SetFunctions::Floatset_degrees) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("radians", {SetTypes::floatset()}, SetTypes::floatset(), SetFunctions::Floatset_radians) - ); + // floor/ceil/round/degrees/radians on floatset are float-base scalar transforms + // generated from the catalog (generated_temporal_udfs.cpp): both the full arity + // and the shorter DEFAULT-arg overload (round(floatset,integer DEFAULT 0), + // degrees(floatset,boolean DEFAULT FALSE)) come from sqlSignatures argDefaults, + // so no hand registration remains. - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {SetTypes::textset()}, SetTypes::textset(), SetFunctions::Textset_lower) ); @@ -354,225 +266,11 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction("||", {SetTypes::textset(), LogicalType::VARCHAR}, SetTypes::textset(), SetFunctions::Textcat_textset_text) ); - // --- set_contains / @> --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contains", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Contains_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contains_set_set)); + // --- set_contained / <@ --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_contained", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contained_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Contained_set_set)); - - // --- set_overlaps / && --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overlaps", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overlaps_set_set)); - - // --- Position: set_left / << --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_left", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Left_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Left_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Left_set_set)); - - // --- set_right / >> --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_right", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Right_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Right_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Right_set_set)); - - // --- set_overleft / &< --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overleft", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overleft_set_set)); - - // --- set_overright / &> --- - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_overright", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::INTEGER, SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::intset(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::BIGINT, SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::bigintset(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::DOUBLE, SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::floatset(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::VARCHAR, SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::textset(), LogicalType::VARCHAR}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::textset(), SetTypes::textset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::DATE, SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::dateset(), LogicalType::DATE}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::TIMESTAMP_TZ, SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overright_value_set)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::tstzset(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SetFunctions::Overright_set_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Overright_set_set)); + + // --- set_union / + (value forms) --- duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_union", {LogicalType::INTEGER, SetTypes::intset()}, SetTypes::intset(), SetFunctions::Union_value_set)); @@ -747,7 +445,6 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {SetTypes::dateset(), SetTypes::dateset()}, LogicalType::BOOLEAN, SetFunctions::Set_ne)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {SetTypes::tstzset(), SetTypes::tstzset()}, LogicalType::BOOLEAN, SetFunctions::Set_ne)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_lt", {SetTypes::intset(), SetTypes::intset()}, LogicalType::BOOLEAN, SetFunctions::Set_lt)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_lt", {SetTypes::bigintset(), SetTypes::bigintset()}, LogicalType::BOOLEAN, SetFunctions::Set_lt)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("set_lt", {SetTypes::floatset(), SetTypes::floatset()}, LogicalType::BOOLEAN, SetFunctions::Set_lt)); @@ -815,14 +512,13 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // --- Unnest --- struct SetUnnestBindData : public TableFunctionData { string_t blob; - meosType set_type; + MeosType set_type; LogicalType return_type; - SetUnnestBindData(string_t blob, meosType set_type, LogicalType return_type) + SetUnnestBindData(string_t blob, MeosType set_type, LogicalType return_type) : blob(std::move(blob)), set_type(set_type), return_type(std::move(return_type)) {} }; - struct SetUnnestGlobalState : public GlobalTableFunctionState { idx_t idx = 0; std::vector values; diff --git a/src/temporal/set_functions.cpp b/src/temporal/set_functions.cpp index 71407eee..8964808b 100644 --- a/src/temporal/set_functions.cpp +++ b/src/temporal/set_functions.cpp @@ -207,7 +207,7 @@ bool SetFunctions::Text_to_set(Vector &source, Vector &result, idx_t count, Cast result.SetVectorType(VectorType::FLAT_VECTOR); auto target_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); UnaryExecutor::Execute( source, result, count, @@ -301,7 +301,7 @@ void SetFunctions::Set_constructor(DataChunk &args, ExpressionState &state, Vect } } - meosType base_type = settype_basetype(meos_type); + MeosType base_type = settype_basetype(meos_type); Set *s = set_make_free(values, (int)length, base_type, true); size_t size = set_mem_size(s); @@ -320,7 +320,7 @@ static inline void Write_set(Vector &result, idx_t row, Set *s) { free(s); } -static inline void Value_to_set_core(Vector &source, Vector &result, idx_t count, meosType base_type) { +static inline void Value_to_set_core(Vector &source, Vector &result, idx_t count, MeosType base_type) { source.Flatten(count); result.SetVectorType(VectorType::FLAT_VECTOR); @@ -409,8 +409,8 @@ static inline void Value_to_set_core(Vector &source, Vector &result, idx_t count bool SetFunctions::Value_to_set_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto target_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); - meosType base_type = settype_basetype(set_type); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); + MeosType base_type = settype_basetype(set_type); Value_to_set_core(source, result, count, base_type); return true; @@ -420,8 +420,8 @@ bool SetFunctions::Value_to_set_cast(Vector &source, Vector &result, idx_t count void SetFunctions::Value_to_set(DataChunk &args, ExpressionState &state, Vector &result) { auto &source = args.data[0]; auto out_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); - meosType base_type = settype_basetype(set_type); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType base_type = settype_basetype(set_type); Value_to_set_core(source, result, args.size(), base_type); } @@ -860,107 +860,12 @@ void SetFunctions::Set_value_n(DataChunk &args, ExpressionState &state, Vector & // --- getValues --- -void SetFunctions::Set_values(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - idx_t row_count = args.size(); - - auto set_type_alias = SetTypeMapping::GetMeosTypeFromAlias(input.GetType().ToString()); - auto base_type = settype_basetype(set_type_alias); // MEOS base type enum - auto child_type = SetTypeMapping::GetChildType(input.GetType()); // DuckDB LogicalType - - auto &result_validity = FlatVector::Validity(result); - auto list_entries = FlatVector::GetData(result); - auto &child_vector = ListVector::GetEntry(result); - - child_vector.SetVectorType(VectorType::FLAT_VECTOR); - ListVector::Reserve(result, row_count); - idx_t total_offset = 0; - - for (idx_t i = 0; i < row_count; ++i) { - if (input.GetValue(i).IsNull()) { - result_validity.SetInvalid(i); - continue; - } - - string_t blob = FlatVector::GetData(input)[i]; - const uint8_t *data = (const uint8_t *)(blob.GetData()); - size_t size = blob.GetSize(); - Set *s = (Set*)malloc(size); - memcpy(s, data, size); - if (!s) { - result_validity.SetInvalid(i); - continue; - } - - uint64_t count = s->count; - Datum *values = set_vals(s); - - ListVector::SetListSize(result, total_offset + count); - list_entries[i] = list_entry_t{total_offset, count}; - - switch (base_type) { - case T_INT4: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - data[total_offset + j] = int32(values[j]); - } - break; - } - case T_INT8: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - data[total_offset + j] = int64(values[j]); - } - break; - } - case T_FLOAT8: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - data[total_offset + j] = DatumGetFloat8(values[j]); - } - break; - } - case T_TEXT: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - text *txt = (text *)DatumGetPointer(values[j]); - string str(VARDATA(txt), VARSIZE(txt) - VARHDRSZ); - data[total_offset + j] = StringVector::AddString(child_vector, str); - } - break; - } - case T_DATE: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - data[total_offset + j] = date_t(FromMeosDate(int32(values[j]))); - } - break; - } - case T_TIMESTAMPTZ: { - auto data = FlatVector::GetData(child_vector); - for (int j = 0; j < count; ++j) { - data[total_offset + j] = timestamp_t(FromMeosTimestamp(int64(values[j]))); - } - break; - } - default: - free(values); - free(s); - throw NotImplementedException("Unsupported base type in getValues"); - } - - total_offset += count; - result_validity.SetValid(i); - free(values); - free(s); - } -} // --- shift --- void SetFunctions::Numset_shift(DataChunk &args, ExpressionState &state, Vector &result) { auto &set_vec = args.data[0]; auto out_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (set_type) { case T_INTSET: { // shift(intset, integer) -> intset @@ -1035,7 +940,7 @@ void SetFunctions::Tstzset_shift(DataChunk &args, ExpressionState &state, Vector void SetFunctions::Numset_scale(DataChunk &args, ExpressionState &state, Vector &result){ auto &set_vec = args.data[0]; auto out_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (set_type) { case T_INTSET: { // scale(intset, integer) -> intset @@ -1113,7 +1018,7 @@ void SetFunctions::Numset_shift_scale(DataChunk &args, ExpressionState &state, V auto &wd_vec = args.data[2]; auto out_type = result.GetType(); - meosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType set_type = SetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (set_type) { case T_INTSET: { // shift_scale(intset, integer, integer) -> intset @@ -1189,126 +1094,8 @@ void SetFunctions::Tstzset_shift_scale(DataChunk &args, ExpressionState &state, ); } -// --- Floor (floatset) --- -void SetFunctions::Floatset_floor(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t input_blob) -> string_t { - const uint8_t *data = (const uint8_t *)input_blob.GetData(); - size_t size = input_blob.GetSize(); - Set *s = (Set*)malloc(size); - memcpy(s, data, size); - Set *r = floatset_floor(s); - free(s); - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, set_mem_size(r)); - free(r); - return out; - }); -} - -// --- Ceil (floatset) --- -void SetFunctions::Floatset_ceil(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t input_blob) -> string_t { - const uint8_t *data = (const uint8_t *)input_blob.GetData(); - size_t size = input_blob.GetSize(); - Set *s = (Set*)malloc(size); - memcpy(s, data, size); - Set *r = floatset_ceil(s); - free(s); - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, set_mem_size(r)); - free(r); - return out; - }); -} - -// --- Round (floatset) --- -void SetFunctions::Floatset_round(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input_vec = args.data[0]; - input_vec.Flatten(args.size()); - - bool has_digits = args.ColumnCount() > 1; - Vector *digits_vec_ptr = has_digits ? &args.data[1] : nullptr; - if (has_digits) digits_vec_ptr->Flatten(args.size()); - - for (idx_t i = 0; i < args.size(); i++) { - if (FlatVector::IsNull(input_vec, i) || (has_digits && FlatVector::IsNull(*digits_vec_ptr, i))) { - FlatVector::SetNull(result, i, true); - continue; - } - - auto blob = FlatVector::GetData(input_vec)[i]; - int digits = has_digits ? FlatVector::GetData(*digits_vec_ptr)[i] : 0; - - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - - Set *s = (Set *)malloc(size); - memcpy(s, data, size); - Set *r = set_round(s, digits); - free(s); - string_t str = StringVector::AddStringOrBlob(result, (const char *)r, set_mem_size(r)); - FlatVector::GetData(result)[i] = str; - free(r); - } -} - -// --- Degrees (floatset) --- -void SetFunctions::Floatset_degrees(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input_vec = args.data[0]; - input_vec.Flatten(args.size()); - - bool has_bools = args.ColumnCount() > 1; - Vector *bools_vec_ptr = has_bools ? &args.data[1] : nullptr; - if (has_bools) bools_vec_ptr->Flatten(args.size()); - - for (idx_t i = 0; i < args.size(); i++) { - if (FlatVector::IsNull(input_vec, i) || (has_bools && FlatVector::IsNull(*bools_vec_ptr, i))) { - FlatVector::SetNull(result, i, true); - continue; - } - - auto blob = FlatVector::GetData(input_vec)[i]; - // Registered in set.cpp as a BOOLEAN argument; DuckDB 1.4 asserts the - // Vector's template type matches the declared type, so reading this as - // `int32_t` triggered `Expected INT32, found BOOL` (set.test:227). - bool bools = has_bools ? FlatVector::GetData(*bools_vec_ptr)[i] : false; - - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - - Set *s = (Set *)malloc(size); - memcpy(s, data, size); - Set *r = floatset_degrees(s, bools); - free(s); - string_t str = StringVector::AddStringOrBlob(result, (const char *)r, set_mem_size(r)); - FlatVector::GetData(result)[i] = str; - free(r); - } -} - -// --- Radians (floatset) --- -void SetFunctions::Floatset_radians(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input_vec = args.data[0]; - UnaryExecutor::Execute( - input_vec, result, args.size(), - [&](string_t input_blob) -> string_t { - const uint8_t *data = (const uint8_t *)input_blob.GetData(); - size_t size = input_blob.GetSize(); - Set *s = (Set*)malloc(size); - memcpy(s, data, size); - Set *r = floatset_radians(s); - free(s); - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, set_mem_size(r)); - free(r); - return out; - }); - } +// floor/ceil/round/degrees/radians on floatset are generated from the catalog +// (generated_temporal_udfs.cpp); no hand bodies remain. // --- Textset lower --- void SetFunctions::Textset_lower(DataChunk &args, ExpressionState &state, Vector &result) { diff --git a/src/temporal/span.cpp b/src/temporal/span.cpp index 35086fc3..bf533264 100644 --- a/src/temporal/span.cpp +++ b/src/temporal/span.cpp @@ -25,132 +25,75 @@ extern "C" { namespace duckdb { -#define DEFINE_SPAN_TYPE(NAME) \ - LogicalType SpanTypes::NAME() { \ - auto type = LogicalType(LogicalTypeId::BLOB); \ - type.SetAlias(#NAME); \ - return type; \ - } - -DEFINE_SPAN_TYPE(INTSPAN) -DEFINE_SPAN_TYPE(BIGINTSPAN) -DEFINE_SPAN_TYPE(FLOATSPAN) -DEFINE_SPAN_TYPE(DATESPAN) -DEFINE_SPAN_TYPE(TSTZSPAN) - -#undef DEFINE_SPAN_TYPE - -void SpanTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "INTSPAN", INTSPAN()); - loader.RegisterType( "BIGINTSPAN", BIGINTSPAN()); - loader.RegisterType( "FLOATSPAN", FLOATSPAN()); - loader.RegisterType( "DATESPAN", DATESPAN()); - loader.RegisterType( "TSTZSPAN", TSTZSPAN()); -} - -const std::vector &SpanTypes::AllTypes() { - static std::vector types = { - INTSPAN(), - BIGINTSPAN(), - FLOATSPAN(), - DATESPAN(), - TSTZSPAN() - }; - return types; -} - -meosType SpanTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { - static const std::unordered_map alias_to_type = { - {"INTSPAN", T_INTSPAN}, - {"BIGINTSPAN", T_BIGINTSPAN}, - {"FLOATSPAN", T_FLOATSPAN}, - {"DATESPAN", T_DATESPAN}, - {"TSTZSPAN", T_TSTZSPAN} - }; +// Collection type registration (accessors, RegisterTypes, AllTypes, alias->MeosType, +// GetChildType) is generated from the catalog MeosType enum into +// src/generated/generated_type_registration.cpp. - auto it = alias_to_type.find(alias); - if (it != alias_to_type.end()) { - return it->second; - } else { - return T_UNKNOWN; - } -} - -LogicalType SpanTypeMapping::GetChildType(const LogicalType &type) { - auto alias = type.ToString(); - if (alias == "INTSPAN") return LogicalType::INTEGER; - if (alias == "BIGINTSPAN") return LogicalType::BIGINT; - if (alias == "FLOATSPAN") return LogicalType::DOUBLE; - if (alias == "DATESPAN") return LogicalType::DATE; - if (alias == "TSTZSPAN") return LogicalType::TIMESTAMP_TZ; - throw NotImplementedException("GetChildType: unsupported alias: " + alias); -} - -// Register all cast functions +// Register all cast functions void SpanTypes::RegisterCastFunctions(ExtensionLoader &loader) { for (const auto &span_type : SpanTypes::AllTypes()) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, span_type, LogicalType::VARCHAR, SpanFunctions::Span_to_text ); // Blob to text - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, span_type, SpanFunctions::Text_to_span ); // text to blob - loader.RegisterCastFunction( - SpanTypes::INTSPAN(), - SpanTypes::FLOATSPAN(), + RegisterMeosCastFunction(loader, + SpanTypes::intspan(), + SpanTypes::floatspan(), SpanFunctions::Intspan_to_floatspan_cast // intspan -> floatspan ); - loader.RegisterCastFunction( - SpanTypes::FLOATSPAN(), - SpanTypes::INTSPAN(), + RegisterMeosCastFunction(loader, + SpanTypes::floatspan(), + SpanTypes::intspan(), SpanFunctions::Floatspan_to_intspan_cast // floatspan -> intspan ); - loader.RegisterCastFunction( - SpanTypes::DATESPAN(), - SpanTypes::TSTZSPAN(), + RegisterMeosCastFunction(loader, + SpanTypes::datespan(), + SpanTypes::tstzspan(), SpanFunctions::Datespan_to_tstzspan_cast // datespan -> tstzspan ); - loader.RegisterCastFunction( - SpanTypes::TSTZSPAN(), - SpanTypes::DATESPAN(), + RegisterMeosCastFunction(loader, + SpanTypes::tstzspan(), + SpanTypes::datespan(), SpanFunctions::Tstzspan_to_datespan_cast // tstzspan -> datespan ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::intset(), - SpanTypes::INTSPAN(), + SpanTypes::intspan(), SpanFunctions::Set_to_span_cast // intset -> intspan ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::bigintset(), - SpanTypes::BIGINTSPAN(), + SpanTypes::bigintspan(), SpanFunctions::Set_to_span_cast // bigintset -> bigintspan ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::floatset(), - SpanTypes::FLOATSPAN(), + SpanTypes::floatspan(), SpanFunctions::Set_to_span_cast // floatset -> floatspan ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::tstzset(), - SpanTypes::TSTZSPAN(), + SpanTypes::tstzspan(), SpanFunctions::Set_to_span_cast // tstzset -> tstzspan ); // Scalar value -> span casts - loader.RegisterCastFunction(LogicalType::INTEGER, SpanTypes::INTSPAN(), SpanFunctions::Value_to_span_cast); - loader.RegisterCastFunction(LogicalType::BIGINT, SpanTypes::BIGINTSPAN(), SpanFunctions::Value_to_span_cast); - loader.RegisterCastFunction(LogicalType::DOUBLE, SpanTypes::FLOATSPAN(), SpanFunctions::Value_to_span_cast); - loader.RegisterCastFunction(LogicalType::DATE, SpanTypes::DATESPAN(), SpanFunctions::Value_to_span_cast); - loader.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN(), SpanFunctions::Value_to_span_cast); + RegisterMeosCastFunction(loader, LogicalType::INTEGER, SpanTypes::intspan(), SpanFunctions::Value_to_span_cast); + RegisterMeosCastFunction(loader, LogicalType::BIGINT, SpanTypes::bigintspan(), SpanFunctions::Value_to_span_cast); + RegisterMeosCastFunction(loader, LogicalType::DOUBLE, SpanTypes::floatspan(), SpanFunctions::Value_to_span_cast); + RegisterMeosCastFunction(loader, LogicalType::DATE, SpanTypes::datespan(), SpanFunctions::Value_to_span_cast); + RegisterMeosCastFunction(loader, LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan(), SpanFunctions::Value_to_span_cast); } } @@ -159,7 +102,7 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto base_type = SpanTypeMapping::GetChildType(span_type); // Register: asText - if (span_type == SpanTypes::FLOATSPAN()) { + if (span_type == SpanTypes::floatspan()) { duckdb::RegisterSerializedScalarFunction(loader, // asText(floatspan) ScalarFunction("asText", {span_type}, LogicalType::VARCHAR, SpanFunctions::Span_as_text) ); @@ -206,40 +149,39 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("intspan", {SpanTypes::FLOATSPAN()}, SpanTypes::INTSPAN(), SpanFunctions::Floatspan_to_intspan) + ScalarFunction("intspan", {SpanTypes::floatspan()}, SpanTypes::intspan(), SpanFunctions::Floatspan_to_intspan) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("floatspan", {SpanTypes::INTSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Intspan_to_floatspan) + ScalarFunction("floatspan", {SpanTypes::intspan()}, SpanTypes::floatspan(), SpanFunctions::Intspan_to_floatspan) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("datespan", {SpanTypes::TSTZSPAN()}, SpanTypes::DATESPAN(), SpanFunctions::Tstzspan_to_datespan) + ScalarFunction("datespan", {SpanTypes::tstzspan()}, SpanTypes::datespan(), SpanFunctions::Tstzspan_to_datespan) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("tstzspan", {SpanTypes::DATESPAN()}, SpanTypes::TSTZSPAN(), SpanFunctions::Datespan_to_tstzspan) + ScalarFunction("tstzspan", {SpanTypes::datespan()}, SpanTypes::tstzspan(), SpanFunctions::Datespan_to_tstzspan) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span", {SetTypes::intset()},SpanTypes::INTSPAN(), SpanFunctions::Set_to_span) + ScalarFunction("span", {SetTypes::intset()},SpanTypes::intspan(), SpanFunctions::Set_to_span) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span", {SetTypes::bigintset()},SpanTypes::BIGINTSPAN(), SpanFunctions::Set_to_span) + ScalarFunction("span", {SetTypes::bigintset()},SpanTypes::bigintspan(), SpanFunctions::Set_to_span) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span", {SetTypes::floatset()},SpanTypes::FLOATSPAN(), SpanFunctions::Set_to_span) + ScalarFunction("span", {SetTypes::floatset()},SpanTypes::floatspan(), SpanFunctions::Set_to_span) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span", {SetTypes::tstzset()},SpanTypes::TSTZSPAN(), SpanFunctions::Set_to_span) + ScalarFunction("span", {SetTypes::tstzset()},SpanTypes::tstzspan(), SpanFunctions::Set_to_span) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span", {SetTypes::dateset()},SpanTypes::DATESPAN(), SpanFunctions::Set_to_span) + ScalarFunction("span", {SetTypes::dateset()},SpanTypes::datespan(), SpanFunctions::Set_to_span) ); - if (span_type == SpanTypes::INTSPAN() ||span_type == SpanTypes::DATESPAN()){ + if (span_type == SpanTypes::intspan() ||span_type == SpanTypes::datespan()){ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {span_type, LogicalType::INTEGER}, span_type, SpanFunctions::Numspan_shift) ); @@ -251,7 +193,7 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { SpanFunctions::Numspan_shift_scale)); } - else if( span_type == SpanTypes::BIGINTSPAN() ){ + else if( span_type == SpanTypes::bigintspan() ){ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {span_type, LogicalType::BIGINT}, span_type, SpanFunctions::Numspan_shift) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {span_type, LogicalType::INTERVAL}, span_type, SpanFunctions::Numspan_expand) @@ -262,7 +204,7 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction("shiftScale", {span_type, LogicalType::BIGINT, LogicalType::BIGINT}, span_type, SpanFunctions::Numspan_shift_scale) ); } - else if( span_type == SpanTypes::FLOATSPAN() ){ + else if( span_type == SpanTypes::floatspan() ){ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {span_type, LogicalType::DOUBLE}, span_type, SpanFunctions::Numspan_shift) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("expand", {span_type, LogicalType::INTERVAL}, span_type, SpanFunctions::Numspan_expand) @@ -274,7 +216,7 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ); } - else if( span_type == SpanTypes::TSTZSPAN() ){ + else if( span_type == SpanTypes::tstzspan() ){ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {span_type, LogicalType::INTERVAL}, span_type, SpanFunctions::Tstzspan_shift) ); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {span_type, LogicalType::INTERVAL}, span_type, SpanFunctions::Tstzspan_shift) @@ -302,149 +244,115 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("expand", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpanTypes::INTSPAN(), SpanFunctions::Numspan_expand) + ScalarFunction("expand", {SpanTypes::intspan(), LogicalType::INTEGER}, SpanTypes::intspan(), SpanFunctions::Numspan_expand) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("expand", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpanTypes::BIGINTSPAN(), SpanFunctions::Numspan_expand) + ScalarFunction("expand", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpanTypes::bigintspan(), SpanFunctions::Numspan_expand) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("expand", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpanTypes::FLOATSPAN(), SpanFunctions::Numspan_expand) + ScalarFunction("expand", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpanTypes::floatspan(), SpanFunctions::Numspan_expand) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("expand", {SpanTypes::DATESPAN(), LogicalType::INTEGER}, SpanTypes::DATESPAN(), SpanFunctions::Numspan_expand) + ScalarFunction("expand", {SpanTypes::datespan(), LogicalType::INTEGER}, SpanTypes::datespan(), SpanFunctions::Numspan_expand) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("expand", {SpanTypes::TSTZSPAN(), LogicalType::INTERVAL}, SpanTypes::TSTZSPAN(), SpanFunctions::Tstzspan_expand) + ScalarFunction("expand", {SpanTypes::tstzspan(), LogicalType::INTERVAL}, SpanTypes::tstzspan(), SpanFunctions::Tstzspan_expand) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("width", {SpanTypes::INTSPAN()}, LogicalType::INTEGER, SpanFunctions::Numspan_width) + ScalarFunction("width", {SpanTypes::intspan()}, LogicalType::INTEGER, SpanFunctions::Numspan_width) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("width", {SpanTypes::BIGINTSPAN()}, LogicalType::BIGINT, SpanFunctions::Numspan_width) + ScalarFunction("width", {SpanTypes::bigintspan()}, LogicalType::BIGINT, SpanFunctions::Numspan_width) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("width", {SpanTypes::FLOATSPAN()}, LogicalType::DOUBLE, SpanFunctions::Numspan_width) + ScalarFunction("width", {SpanTypes::floatspan()}, LogicalType::DOUBLE, SpanFunctions::Numspan_width) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("duration", {SpanTypes::DATESPAN()}, LogicalType::INTERVAL, SpanFunctions::Datespan_duration) + ScalarFunction("duration", {SpanTypes::datespan()}, LogicalType::INTERVAL, SpanFunctions::Datespan_duration) ); duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("duration", {SpanTypes::TSTZSPAN()}, LogicalType::INTERVAL, SpanFunctions::Tstzspan_duration) + ScalarFunction("duration", {SpanTypes::tstzspan()}, LogicalType::INTERVAL, SpanFunctions::Tstzspan_duration) ); + // spans() is generated from the catalog (set_spans) in generated_temporal_udfs.cpp. - - // spans() — list of unit spans, one per set element - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {SetTypes::intset()}, - LogicalType::LIST(SpanTypes::INTSPAN()), SpanFunctions::Set_spans)); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {SetTypes::bigintset()}, - LogicalType::LIST(SpanTypes::BIGINTSPAN()), SpanFunctions::Set_spans)); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {SetTypes::floatset()}, - LogicalType::LIST(SpanTypes::FLOATSPAN()), SpanFunctions::Set_spans)); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {SetTypes::dateset()}, - LogicalType::LIST(SpanTypes::DATESPAN()), SpanFunctions::Set_spans)); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {SetTypes::tstzset()}, - LogicalType::LIST(SpanTypes::TSTZSPAN()), SpanFunctions::Set_spans)); - - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {SetTypes::intset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::INTSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {SetTypes::bigintset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::BIGINTSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {SetTypes::floatset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::FLOATSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {SetTypes::dateset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::DATESPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {SetTypes::tstzset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::TSTZSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNSpans", {SetTypes::intset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::INTSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNSpans", {SetTypes::bigintset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::BIGINTSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNSpans", {SetTypes::floatset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::FLOATSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNSpans", {SetTypes::dateset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::DATESPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNSpans", {SetTypes::tstzset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::TSTZSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_each_n_spans)); // Lowercase-"spans" aliases matching MobilityDB's SQL surface // (`splitNspans` / `splitEachNspans`). The camelCase forms above // stay registered for back-compat with existing MobilityDuck callers. duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNspans", {SetTypes::intset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::INTSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNspans", {SetTypes::bigintset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::BIGINTSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNspans", {SetTypes::floatset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::FLOATSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNspans", {SetTypes::dateset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::DATESPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNspans", {SetTypes::tstzset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::TSTZSPAN()), SpanFunctions::Set_split_n_spans)); + LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNspans", {SetTypes::intset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::INTSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNspans", {SetTypes::bigintset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::BIGINTSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNspans", {SetTypes::floatset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::FLOATSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNspans", {SetTypes::dateset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::DATESPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_each_n_spans)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNspans", {SetTypes::tstzset(), LogicalType::INTEGER}, - LogicalType::LIST(SpanTypes::TSTZSPAN()), SpanFunctions::Set_split_each_n_spans)); + LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_each_n_spans)); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("floor", {SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_floor) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("ceil", {SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_ceil) - ); - duckdb::RegisterSerializedScalarFunction(loader, + // floor/ceil/round/degrees/radians on floatspan are float-base scalar transforms + // generated from the catalog (generated_temporal_udfs.cpp), full arity plus the + // shorter DEFAULT-arg overload via sqlSignatures argDefaults. Only round(DOUBLE), + // the scalar base helper with no catalog signature, remains hand-registered. + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("round", {LogicalType::DOUBLE}, LogicalType::DOUBLE, SpanFunctions::Float_round) ); - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("round", {LogicalType::DOUBLE, LogicalType::INTEGER}, LogicalType::DOUBLE, SpanFunctions::Float_round) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("round", {SpanTypes::FLOATSPAN(), LogicalType::INTEGER}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_round) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("round", {SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_round) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("degrees", {SpanTypes::FLOATSPAN(), LogicalType::BOOLEAN}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_degrees) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("degrees", {SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_degrees) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("radians", {SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Floatspan_radians) - ); for (const auto &span_type : SpanTypes::AllTypes()) { duckdb::RegisterSerializedScalarFunction(loader, @@ -492,688 +400,268 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ); } - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("span_contains", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("@>", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contains_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_contained", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Contained_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overlaps", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overlaps", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overlaps", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overlaps", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overlaps", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overlaps_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {LogicalType::BIGINT,SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::BIGINT,SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_adjacent", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Adjacent_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Left_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_left", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<#", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Left_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Right_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_right", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#>>", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Right_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<#", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<#", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<#", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overleft", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<#", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overleft_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::intspan(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::INTEGER, SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Union_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) +loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::intspan(), SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::intspan(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::INTEGER, SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Union_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) +loader.RegisterFunction( ScalarFunction("+", {SpanTypes::intspan(), SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_value_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_overright", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("#&>", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, SpanFunctions::Overright_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("+", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("+", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("+", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("+", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::datespan(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Union_span_value) ); -loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::DATE, SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Union_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_value) +loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::datespan(), SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::datespan(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Union_span_value) ); -loader.RegisterFunction( ScalarFunction("+", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Union_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DATE, SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Union_value_span) ); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Union_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Union_value_span) - ); -loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Union_span_span) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Union_span_value) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Union_value_span) - ); -loader.RegisterFunction( ScalarFunction("+", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("+", {SpanTypes::datespan(), SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_union", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("span_union", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_value_span) ); -loader.RegisterFunction( ScalarFunction("+", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_span) +loader.RegisterFunction( ScalarFunction("+", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Union_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::intspan(), LogicalType::INTEGER}, SpanTypes::intspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::INTEGER, SpanTypes::intspan()}, SpanTypes::intspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::intspan(), SpanTypes::intspan()}, SpanTypes::intspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::intspan(), LogicalType::INTEGER}, SpanTypes::intspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::INTEGER, SpanTypes::intspan()}, SpanTypes::intspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpanTypes::INTSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::intspan(), SpanTypes::intspan()}, SpanTypes::intspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpanTypes::bigintspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpanTypes::bigintspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpanTypes::bigintspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpanTypes::bigintspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpanTypes::bigintspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpanTypes::BIGINTSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpanTypes::bigintspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpanTypes::floatspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpanTypes::floatspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpanTypes::floatspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpanTypes::floatspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpanTypes::floatspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpanTypes::FLOATSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpanTypes::floatspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::datespan(), LogicalType::DATE}, SpanTypes::datespan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::DATE, SpanTypes::datespan()}, SpanTypes::datespan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::datespan(), SpanTypes::datespan()}, SpanTypes::datespan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::datespan(), LogicalType::DATE}, SpanTypes::datespan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DATE, SpanTypes::datespan()}, SpanTypes::datespan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpanTypes::DATESPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::datespan(), SpanTypes::datespan()}, SpanTypes::datespan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpanTypes::tstzspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpanTypes::tstzspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_intersection", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpanTypes::tstzspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpanTypes::tstzspan(), SpanFunctions::Intersection_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpanTypes::tstzspan(), SpanFunctions::Intersection_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpanTypes::TSTZSPAN(), SpanFunctions::Intersection_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpanTypes::tstzspan(), SpanFunctions::Intersection_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::intspan(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::INTEGER, SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::intspan(), SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::intspan(), LogicalType::INTEGER}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::INTEGER, SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::intspan(), SpanTypes::intspan()}, SpansetTypes::intspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::bigintspan(), LogicalType::BIGINT}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::BIGINT, SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, SpansetTypes::bigintspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::floatspan(), LogicalType::DOUBLE}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DOUBLE, SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::floatspan(), SpanTypes::floatspan()}, SpansetTypes::floatspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::datespan(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::DATE, SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::datespan(), SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::DATESPAN(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::datespan(), LogicalType::DATE}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DATE, SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DATE, SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::datespan(), SpanTypes::datespan()}, SpansetTypes::datespanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_minus", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, SpansetTypes::tstzspanset(), SpanFunctions::Minus_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::intspan(), SpanTypes::intspan()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::INTSPAN(), LogicalType::INTEGER}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::intspan(), LogicalType::INTEGER}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::INTEGER, SpanTypes::INTSPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::INTEGER, SpanTypes::intspan()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::INTSPAN(), SpanTypes::INTSPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::intspan(), SpanTypes::intspan()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BIGINT, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BIGINT, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BIGINT, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BIGINT, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BIGINT, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, LogicalType::BIGINT, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::BIGINTSPAN(), LogicalType::BIGINT}, LogicalType::BIGINT, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::bigintspan(), LogicalType::BIGINT}, LogicalType::BIGINT, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::BIGINT, SpanTypes::BIGINTSPAN()}, LogicalType::BIGINT, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::BIGINT, SpanTypes::bigintspan()}, LogicalType::BIGINT, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::BIGINTSPAN(), SpanTypes::BIGINTSPAN()}, LogicalType::BIGINT, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::bigintspan(), SpanTypes::bigintspan()}, LogicalType::BIGINT, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::DOUBLE, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::DOUBLE, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::DOUBLE, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::DOUBLE, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::DOUBLE, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::floatspan(), SpanTypes::floatspan()}, LogicalType::DOUBLE, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::FLOATSPAN(), LogicalType::DOUBLE}, LogicalType::DOUBLE, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::floatspan(), LogicalType::DOUBLE}, LogicalType::DOUBLE, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::DOUBLE, SpanTypes::FLOATSPAN()}, LogicalType::DOUBLE, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::DOUBLE, SpanTypes::floatspan()}, LogicalType::DOUBLE, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::FLOATSPAN(), SpanTypes::FLOATSPAN()}, LogicalType::DOUBLE, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::floatspan(), SpanTypes::floatspan()}, LogicalType::DOUBLE, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::datespan(), SpanTypes::datespan()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::DATESPAN(), LogicalType::DATE}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::datespan(), LogicalType::DATE}, LogicalType::INTEGER, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::DATE, SpanTypes::DATESPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::DATE, SpanTypes::datespan()}, LogicalType::INTEGER, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::DATESPAN(), SpanTypes::DATESPAN()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::datespan(), SpanTypes::datespan()}, LogicalType::INTEGER, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::INTERVAL, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::INTERVAL, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::INTERVAL, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::INTERVAL, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::INTERVAL, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("span_distance", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, LogicalType::INTERVAL, SpanFunctions::Distance_span_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::TSTZSPAN(), LogicalType::TIMESTAMP_TZ}, LogicalType::INTERVAL, SpanFunctions::Distance_span_value) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::tstzspan(), LogicalType::TIMESTAMP_TZ}, LogicalType::INTERVAL, SpanFunctions::Distance_span_value) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN()}, LogicalType::INTERVAL, SpanFunctions::Distance_value_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan()}, LogicalType::INTERVAL, SpanFunctions::Distance_value_span) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::TSTZSPAN(), SpanTypes::TSTZSPAN()}, LogicalType::INTERVAL, SpanFunctions::Distance_span_span) + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {SpanTypes::tstzspan(), SpanTypes::tstzspan()}, LogicalType::INTERVAL, SpanFunctions::Distance_span_span) ); } - } // namespace duckdb #ifndef MOBILITYDUCK_EXTENSION_TYPES diff --git a/src/temporal/span_aggregates.cpp b/src/temporal/span_aggregates.cpp index b891c034..64068473 100644 --- a/src/temporal/span_aggregates.cpp +++ b/src/temporal/span_aggregates.cpp @@ -378,13 +378,13 @@ static AggregateFunction MakeExtentBlobToSpanAggregate(const LogicalType &input_ template static AggregateFunction MakeExtentTboxAggregate(const LogicalType &input_type) { return AggregateFunction::UnaryAggregate>( - input_type, TboxType::TBOX()); + input_type, TboxType::tbox()); } template static AggregateFunction MakeExtentStboxAggregate(const LogicalType &input_type) { return AggregateFunction::UnaryAggregate>( - input_type, StboxType::STBOX()); + input_type, StboxType::stbox()); } } // namespace @@ -393,23 +393,23 @@ void SpanAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { AggregateFunctionSet extent_set("extent"); // ---- extent(span) for all 5 span types ---- - for (const auto &span_type : {SpanTypes::INTSPAN(), SpanTypes::BIGINTSPAN(), - SpanTypes::FLOATSPAN(), SpanTypes::DATESPAN(), - SpanTypes::TSTZSPAN()}) { + for (const auto &span_type : {SpanTypes::intspan(), SpanTypes::bigintspan(), + SpanTypes::floatspan(), SpanTypes::datespan(), + SpanTypes::tstzspan()}) { extent_set.AddFunction(MakeExtentSpanAggregate(span_type)); } // ---- extent(scalar) -> typed span ---- extent_set.AddFunction(MakeExtentScalarAggregate( - LogicalType::INTEGER, SpanTypes::INTSPAN())); + LogicalType::INTEGER, SpanTypes::intspan())); extent_set.AddFunction(MakeExtentScalarAggregate( - LogicalType::BIGINT, SpanTypes::BIGINTSPAN())); + LogicalType::BIGINT, SpanTypes::bigintspan())); extent_set.AddFunction(MakeExtentScalarAggregate( - LogicalType::DOUBLE, SpanTypes::FLOATSPAN())); + LogicalType::DOUBLE, SpanTypes::floatspan())); extent_set.AddFunction(MakeExtentScalarAggregate( - LogicalType::DATE, SpanTypes::DATESPAN())); + LogicalType::DATE, SpanTypes::datespan())); extent_set.AddFunction(MakeExtentScalarAggregate( - LogicalType::TIMESTAMP_TZ, SpanTypes::TSTZSPAN())); + LogicalType::TIMESTAMP_TZ, SpanTypes::tstzspan())); // ---- extent(set) -> typed span ---- struct SetSpanPair { @@ -417,11 +417,11 @@ void SpanAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { LogicalType out; }; const std::vector set_pairs = { - {SetTypes::intset(), SpanTypes::INTSPAN()}, - {SetTypes::bigintset(), SpanTypes::BIGINTSPAN()}, - {SetTypes::floatset(), SpanTypes::FLOATSPAN()}, - {SetTypes::dateset(), SpanTypes::DATESPAN()}, - {SetTypes::tstzset(), SpanTypes::TSTZSPAN()}, + {SetTypes::intset(), SpanTypes::intspan()}, + {SetTypes::bigintset(), SpanTypes::bigintspan()}, + {SetTypes::floatset(), SpanTypes::floatspan()}, + {SetTypes::dateset(), SpanTypes::datespan()}, + {SetTypes::tstzset(), SpanTypes::tstzspan()}, }; for (const auto &p : set_pairs) { extent_set.AddFunction(MakeExtentBlobToSpanAggregate(p.in, p.out)); @@ -429,54 +429,54 @@ void SpanAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { // ---- extent(spanset) -> typed span ---- const std::vector spanset_pairs = { - {SpansetTypes::intspanset(), SpanTypes::INTSPAN()}, - {SpansetTypes::bigintspanset(), SpanTypes::BIGINTSPAN()}, - {SpansetTypes::floatspanset(), SpanTypes::FLOATSPAN()}, - {SpansetTypes::datespanset(), SpanTypes::DATESPAN()}, - {SpansetTypes::tstzspanset(), SpanTypes::TSTZSPAN()}, + {SpansetTypes::intspanset(), SpanTypes::intspan()}, + {SpansetTypes::bigintspanset(), SpanTypes::bigintspan()}, + {SpansetTypes::floatspanset(), SpanTypes::floatspan()}, + {SpansetTypes::datespanset(), SpanTypes::datespan()}, + {SpansetTypes::tstzspanset(), SpanTypes::tstzspan()}, }; for (const auto &p : spanset_pairs) { extent_set.AddFunction(MakeExtentBlobToSpanAggregate(p.in, p.out)); } // ---- extent(tbox) -> tbox; extent(tnumber) -> tbox ---- - extent_set.AddFunction(MakeExtentTboxAggregate(TboxType::TBOX())); - extent_set.AddFunction(MakeExtentTboxAggregate(TemporalTypes::TINT())); - extent_set.AddFunction(MakeExtentTboxAggregate(TemporalTypes::TFLOAT())); + extent_set.AddFunction(MakeExtentTboxAggregate(TboxType::tbox())); + extent_set.AddFunction(MakeExtentTboxAggregate(TemporalTypes::tint())); + extent_set.AddFunction(MakeExtentTboxAggregate(TemporalTypes::tfloat())); // ---- extent(stbox | tgeompoint | tgeometry) -> stbox ---- - extent_set.AddFunction(MakeExtentStboxAggregate(StboxType::STBOX())); + extent_set.AddFunction(MakeExtentStboxAggregate(StboxType::stbox())); { // tgeompoint / tgeometry are registered via their respective Type // helpers; we avoid pulling those headers here by using a // BLOB-aliased clone since the underlying MEOS extent transition // function (`tspatial_extent_transfn`) is subtype-agnostic. LogicalType tgeompoint_type(LogicalTypeId::BLOB); - tgeompoint_type.SetAlias("TGEOMPOINT"); + tgeompoint_type.SetAlias("tgeompoint"); extent_set.AddFunction( MakeExtentStboxAggregate(tgeompoint_type)); LogicalType tgeometry_type(LogicalTypeId::BLOB); - tgeometry_type.SetAlias("TGEOMETRY"); + tgeometry_type.SetAlias("tgeometry"); extent_set.AddFunction( MakeExtentStboxAggregate(tgeometry_type)); LogicalType tgeography_type(LogicalTypeId::BLOB); - tgeography_type.SetAlias("TGEOGRAPHY"); + tgeography_type.SetAlias("tgeography"); extent_set.AddFunction( MakeExtentStboxAggregate(tgeography_type)); LogicalType tgeogpoint_type(LogicalTypeId::BLOB); - tgeogpoint_type.SetAlias("TGEOGPOINT"); + tgeogpoint_type.SetAlias("tgeogpoint"); extent_set.AddFunction( MakeExtentStboxAggregate(tgeogpoint_type)); } // ---- extent(tbool/ttext) -> tstzspan ---- extent_set.AddFunction(MakeExtentBlobToSpanAggregate( - TemporalTypes::TBOOL(), SpanTypes::TSTZSPAN())); + TemporalTypes::tbool(), SpanTypes::tstzspan())); extent_set.AddFunction(MakeExtentBlobToSpanAggregate( - TemporalTypes::TTEXT(), SpanTypes::TSTZSPAN())); + TemporalTypes::ttext(), SpanTypes::tstzspan())); loader.RegisterFunction(std::move(extent_set)); } diff --git a/src/temporal/span_functions.cpp b/src/temporal/span_functions.cpp index 8c6f5bdb..8208cda9 100644 --- a/src/temporal/span_functions.cpp +++ b/src/temporal/span_functions.cpp @@ -88,7 +88,7 @@ bool SpanFunctions::Text_to_span(Vector &source, Vector &result, idx_t count, Ca std::string type_alias = result_type.GetAlias(); // Map the alias to the correct MEOS type - meosType target_meos_type = SpanTypeMapping::GetMeosTypeFromAlias(type_alias); + MeosType target_meos_type = SpanTypeMapping::GetMeosTypeFromAlias(type_alias); if (target_meos_type == T_UNKNOWN) { throw InvalidInputException("Unknown span type: " + type_alias); @@ -203,7 +203,7 @@ void SpanFunctions::Span_constructor(DataChunk &args, ExpressionState &state, Ve auto &result_type = result.GetType(); std::string type_alias = result_type.GetAlias(); - meosType target_meos_type = SpanTypeMapping::GetMeosTypeFromAlias(type_alias); + MeosType target_meos_type = SpanTypeMapping::GetMeosTypeFromAlias(type_alias); if (target_meos_type == T_UNKNOWN) { throw InvalidInputException("Unknown span type: " + type_alias); @@ -239,9 +239,9 @@ void SpanFunctions::Span_constructor(DataChunk &args, ExpressionState &state, Ve // --- Span binary constructor --- -static string_t Span_make_blob(Datum lower_dat, Datum upper_dat, bool lower_inc, bool upper_inc, meosType span_type, +static string_t Span_make_blob(Datum lower_dat, Datum upper_dat, bool lower_inc, bool upper_inc, MeosType span_type, Vector &result) { - meosType basetype = spantype_basetype(span_type); + MeosType basetype = spantype_basetype(span_type); Span *span = span_make(lower_dat, upper_dat, lower_inc, upper_inc, basetype); if (span == NULL) { throw InvalidInputException("Failed to create span from bounds"); @@ -260,7 +260,7 @@ void SpanFunctions::Span_binary_constructor(DataChunk &args, ExpressionState &st Vector *args3 = args.ColumnCount() == 4 ? &args.data[3] : nullptr; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); const idx_t count = args.size(); switch (span_type) { @@ -369,7 +369,7 @@ static inline void Write_span(Vector &result, idx_t row, Span *s) { free(s); } -static void Value_to_span_core(Vector &source, Vector &result, idx_t count, meosType base_type){ +static void Value_to_span_core(Vector &source, Vector &result, idx_t count, MeosType base_type){ source.Flatten(count); result.SetVectorType(VectorType::FLAT_VECTOR); @@ -440,16 +440,16 @@ static void Value_to_span_core(Vector &source, Vector &result, idx_t count, meos void SpanFunctions::Value_to_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &source = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); - meosType base_type = spantype_basetype(span_type); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType base_type = spantype_basetype(span_type); Value_to_span_core(source, result, args.size(), base_type); } bool SpanFunctions::Value_to_span_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(result.GetType().GetAlias()); - meosType base_type = spantype_basetype(span_type); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(result.GetType().GetAlias()); + MeosType base_type = spantype_basetype(span_type); Value_to_span_core(source, result, count, base_type); return true; } @@ -488,57 +488,7 @@ bool SpanFunctions::Set_to_span_cast(Vector &source, Vector &result, idx_t count return true; } -// spans() — returns a LIST() of unit spans, one per -// element of the input set. Mirrors SpansetFunctions::Spanset_spans but -// reads a Set and uses set_spans() / set_num_values() from MEOS. -void SpanFunctions::Set_spans(DataChunk &args, ExpressionState &state, Vector &result) { - auto &set_vec = args.data[0]; - idx_t row_count = args.size(); - set_vec.Flatten(row_count); - - auto &result_validity = FlatVector::Validity(result); - auto list_entries = FlatVector::GetData(result); - auto &child_vector = ListVector::GetEntry(result); - child_vector.SetVectorType(VectorType::FLAT_VECTOR); - ListVector::Reserve(result, row_count); - - idx_t total_offset = 0; - const size_t span_bytes = sizeof(Span); - - for (idx_t i = 0; i < row_count; ++i) { - if (FlatVector::IsNull(set_vec, i)) { - result_validity.SetInvalid(i); - continue; - } - - string_t blob = FlatVector::GetData(set_vec)[i]; - Set *s = (Set *)malloc(blob.GetSize()); - memcpy(s, blob.GetData(), blob.GetSize()); - - int num = set_num_values(s); - Span *spans = set_spans(s); - free(s); - - if (!spans || num <= 0) { - if (spans) free(spans); - result_validity.SetInvalid(i); - continue; - } - - ListVector::SetListSize(result, total_offset + num); - list_entries[i] = list_entry_t{total_offset, static_cast(num)}; - - auto *child_data = FlatVector::GetData(child_vector); - for (int j = 0; j < num; ++j) { - child_data[total_offset + j] = - StringVector::AddStringOrBlob(child_vector, reinterpret_cast(&spans[j]), span_bytes); - } - - free(spans); - total_offset += num; - result_validity.SetValid(i); - } -} +// spans() is generated from the catalog (set_spans) in generated_temporal_udfs.cpp. // --- Conversion: intspan <-> floatspan --- static void Intspan_to_floatspan_common(Vector &source, Vector &result, idx_t count) { @@ -1054,7 +1004,7 @@ void SpanFunctions::Tstzspan_duration(DataChunk &args, ExpressionState &state, V }); } -static inline string_t Numspan_expand_common(const string_t &blob, Datum value, meosType validate_span_type, Vector &result) { +static inline string_t Numspan_expand_common(const string_t &blob, Datum value, MeosType validate_span_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1100,7 +1050,7 @@ static inline string_t Tstzspan_expand_common(const string_t &blob, interval_t d void SpanFunctions::Numspan_expand(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (span_type) { case T_INTSPAN: { // expand(intspan, integer) -> intspan @@ -1146,7 +1096,7 @@ void SpanFunctions::Numspan_expand(DataChunk &args, ExpressionState &state, Vect void SpanFunctions::Tstzspan_expand(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); BinaryExecutor::Execute( span_vec, args.data[1], result, args.size(), [&](string_t blob, interval_t value) -> string_t { @@ -1158,7 +1108,7 @@ void SpanFunctions::Tstzspan_expand(DataChunk &args, ExpressionState &state, Vec } static inline string_t Numspan_shift_common(const string_t &blob, Datum shift_datum, - meosType validate_span_type, Vector &result) { + MeosType validate_span_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1206,7 +1156,7 @@ static inline string_t Tstzspan_shift_common(const string_t &blob, interval_t du void SpanFunctions::Numspan_shift(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (span_type) { case T_INTSPAN: { // shift(intspan, integer) -> intspan @@ -1249,7 +1199,7 @@ void SpanFunctions::Numspan_shift(DataChunk &args, ExpressionState &state, Vecto void SpanFunctions::Tstzspan_shift(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); BinaryExecutor::Execute( span_vec, args.data[1], result, args.size(), [&](string_t blob, interval_t shift_interval) -> string_t { @@ -1261,7 +1211,7 @@ void SpanFunctions::Tstzspan_shift(DataChunk &args, ExpressionState &state, Vect } static inline string_t Numspan_scale_common(const string_t &blob, Datum scale_datum, - meosType validate_span_type, Vector &result) { + MeosType validate_span_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1288,7 +1238,7 @@ static inline string_t Numspan_scale_common(const string_t &blob, Datum scale_da void SpanFunctions::Numspan_scale(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (span_type) { case T_INTSPAN: { // scale(intspan, integer) -> intspan @@ -1351,7 +1301,7 @@ static inline string_t Tstzspan_scale_common(const string_t &blob, interval_t du void SpanFunctions::Tstzspan_scale(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); BinaryExecutor::Execute( span_vec, args.data[1], result, args.size(), [&](string_t blob, interval_t scale_interval) -> string_t { @@ -1386,7 +1336,7 @@ static inline string_t Tstzspan_shift_scale_common(const string_t &blob, interva } static inline string_t Numspan_shift_scale_common(const string_t &blob, Datum shift_datum, Datum scale_datum, - meosType validate_span_type, Vector &result) { + MeosType validate_span_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1423,7 +1373,7 @@ static inline string_t Numspan_shift_scale_common(const string_t &blob, Datum sh void SpanFunctions::Numspan_shift_scale(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; auto out_type = result.GetType(); - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (span_type) { case T_INTSPAN: { @@ -1479,47 +1429,9 @@ void SpanFunctions::Tstzspan_shift_scale(DataChunk &args, ExpressionState &state } } -void SpanFunctions::Floatspan_floor(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_floor(s); - free(s); - if (!r) { - throw InvalidInputException("floatspan_floor failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); -} - -void SpanFunctions::Floatspan_ceil(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_ceil(s); - free(s); - if (!r) { - throw InvalidInputException("floatspan_ceil failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); -} +// floor/ceil/round/degrees/radians on floatspan are generated from the catalog +// (generated_temporal_udfs.cpp); only round(DOUBLE) below, the scalar base helper +// with no catalog signature, remains hand-written. void SpanFunctions::Float_round(DataChunk &args, ExpressionState &state, Vector &result) { D_ASSERT(args.ColumnCount() == 1 || args.ColumnCount() == 2); @@ -1529,13 +1441,14 @@ void SpanFunctions::Float_round(DataChunk &args, ExpressionState &state, Vector BinaryExecutor::Execute( args0, *args1, result, args.size(), [&](double_t float_value, int32_t precision) -> double_t { - return float_round(float_value, precision); + double factor = std::pow(10.0, (double)precision); + return std::round(float_value * factor) / factor; }); } else { UnaryExecutor::Execute( args0, result, args.size(), [&](double_t float_value) -> double_t { - return float_round(float_value, 0); + return std::round(float_value); }); } if (args.size() == 1) { @@ -1543,113 +1456,6 @@ void SpanFunctions::Float_round(DataChunk &args, ExpressionState &state, Vector } } -void SpanFunctions::Floatspan_round(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(args.ColumnCount() == 1 || args.ColumnCount() == 2); - auto &args0 = args.data[0]; - Vector *args1 = args.ColumnCount() == 2 ? &args.data[1] : 0; - if (args.ColumnCount() == 2) { - BinaryExecutor::Execute( - args0, *args1, result, args.size(), - [&](string_t blob, int32_t precision) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_round(s, precision); - free(s); - if (!r) { - throw InvalidInputException("floatspan_round failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } else { - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_round(s, 0); // default precision is 0 - free(s); - if (!r) { - throw InvalidInputException("floatspan_round failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } -} - -void SpanFunctions::Floatspan_degrees(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(args.ColumnCount() == 1|| args.ColumnCount() == 2); - auto &args0 = args.data[0]; - Vector *args1 = args.ColumnCount() == 2 ? &args.data[1] : 0; - if (args.ColumnCount() == 2) { - BinaryExecutor::Execute( - args0, *args1, result, args.size(), - [&](string_t blob, int32_t precision) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_degrees(s, precision); - free(s); - if (!r) { - throw InvalidInputException("floatspan_degrees failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } else { - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_degrees(s, false); // default precision is false - free(s); - if (!r) { - throw InvalidInputException("floatspan_degrees failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } - -} - -void SpanFunctions::Floatspan_radians(DataChunk &args, ExpressionState &state, Vector &result) { - auto &args0 = args.data[0]; - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - Span *s = (Span *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPAN(s, NULL); - Span *r = floatspan_radians(s); - if (!r) { - throw InvalidInputException("floatspan_radians failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - -} // --- OPERATOR: span = span --- void SpanFunctions::Span_eq(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::Execute( @@ -1863,7 +1669,7 @@ void SpanFunctions::Span_cmp(DataChunk &args, ExpressionState &state, Vector &re // --- OPERATOR: span @> value --- void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan @> integer @@ -1877,7 +1683,7 @@ void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = contains_span_value(span, Datum(value)); free(span_data_copy); @@ -1897,7 +1703,7 @@ void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = contains_span_value(span, Datum(value)); free(span_data_copy); @@ -1917,7 +1723,7 @@ void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = contains_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -1936,7 +1742,7 @@ void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = contains_span_value(span, Datum(value)); free(span_data_copy); @@ -1956,7 +1762,7 @@ void SpanFunctions::Contains_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = contains_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2009,7 +1815,7 @@ void SpanFunctions::Contains_span_span(DataChunk &args, ExpressionState &state, // --- OPERATOR: value <@ span --- void SpanFunctions::Contained_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer <@ intspan @@ -2063,7 +1869,7 @@ void SpanFunctions::Contained_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = contains_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -2082,7 +1888,7 @@ void SpanFunctions::Contained_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = contains_span_value(span, Datum(value)); free(span_data_copy); @@ -2102,7 +1908,7 @@ void SpanFunctions::Contained_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = contains_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2194,7 +2000,7 @@ void SpanFunctions::Overlaps_span_span(DataChunk &args, ExpressionState &state, // --- OPERATOR: value -|- span--- void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer -|- intspan @@ -2248,7 +2054,7 @@ void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = adjacent_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -2267,7 +2073,7 @@ void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = adjacent_span_value(span, Datum(value)); free(span_data_copy); @@ -2287,7 +2093,7 @@ void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = adjacent_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2306,7 +2112,7 @@ void SpanFunctions::Adjacent_value_span(DataChunk &args, ExpressionState &state, // --- OPERATOR: span -|- value --- void SpanFunctions::Adjacent_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan -|- integer @@ -2360,7 +2166,7 @@ void SpanFunctions::Adjacent_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = adjacent_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -2379,7 +2185,7 @@ void SpanFunctions::Adjacent_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = adjacent_span_value(span, Datum(value)); free(span_data_copy); @@ -2399,7 +2205,7 @@ void SpanFunctions::Adjacent_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = adjacent_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2454,7 +2260,7 @@ void SpanFunctions::Adjacent_span_span(DataChunk &args, ExpressionState &state, // --- OPERATOR: value << span --- void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer << intspan @@ -2508,7 +2314,7 @@ void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = left_value_span(Float8GetDatum(value), span); free(span_data_copy); @@ -2527,7 +2333,7 @@ void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = left_value_span(Datum(value), span); free(span_data_copy); @@ -2547,7 +2353,7 @@ void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = left_value_span(Datum(ts_meos.value), span); free(span_data_copy); @@ -2565,7 +2371,7 @@ void SpanFunctions::Left_value_span(DataChunk &args, ExpressionState &state, Vec // --- OPERATOR: span << value --- void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan << integer @@ -2619,7 +2425,7 @@ void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = left_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -2638,7 +2444,7 @@ void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = left_span_value(span, Datum(value)); free(span_data_copy); @@ -2658,7 +2464,7 @@ void SpanFunctions::Left_span_value(DataChunk &args, ExpressionState &state, Vec Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = left_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2709,7 +2515,7 @@ void SpanFunctions::Left_span_span(DataChunk &args, ExpressionState &state, Vect // --- OPERATOR: value >> span --- void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer >> intspan @@ -2763,7 +2569,7 @@ void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = right_value_span(Float8GetDatum(value), span); free(span_data_copy); @@ -2782,7 +2588,7 @@ void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = right_value_span(Datum(value), span); free(span_data_copy); @@ -2802,7 +2608,7 @@ void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = right_value_span(Datum(ts_meos.value), span); free(span_data_copy); @@ -2820,7 +2626,7 @@ void SpanFunctions::Right_value_span(DataChunk &args, ExpressionState &state, Ve // --- OPERATOR: span >> value --- void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan >> integer BinaryExecutor::Execute( @@ -2873,7 +2679,7 @@ void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = right_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -2892,7 +2698,7 @@ void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = right_span_value(span, Datum(value)); free(span_data_copy); @@ -2912,7 +2718,7 @@ void SpanFunctions::Right_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = right_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -2964,7 +2770,7 @@ void SpanFunctions::Right_span_span(DataChunk &args, ExpressionState &state, Vec // ---OPERATOR: value &< span --- void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer &< intspan @@ -3018,7 +2824,7 @@ void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = overleft_value_span(Float8GetDatum(value), span); free(span_data_copy); @@ -3037,7 +2843,7 @@ void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = overleft_value_span(Datum(value), span); free(span_data_copy); @@ -3057,7 +2863,7 @@ void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = overleft_value_span(Datum(ts_meos.value), span); free(span_data_copy); @@ -3075,7 +2881,7 @@ void SpanFunctions::Overleft_value_span(DataChunk &args, ExpressionState &state, // ---OPERATOR: span &< value --- void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan &< integer BinaryExecutor::Execute( @@ -3128,7 +2934,7 @@ void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = overleft_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -3147,7 +2953,7 @@ void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = overleft_span_value(span, Datum(value)); free(span_data_copy); @@ -3167,7 +2973,7 @@ void SpanFunctions::Overleft_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = overleft_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -3220,7 +3026,7 @@ void SpanFunctions::Overleft_span_span(DataChunk &args, ExpressionState &state, // --- OPERATOR: value &> span --- void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer &> intspan BinaryExecutor::Execute( @@ -3273,7 +3079,7 @@ void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = overright_value_span(Float8GetDatum(value), span); free(span_data_copy); @@ -3292,7 +3098,7 @@ void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = overright_value_span(Datum(value), span); free(span_data_copy); @@ -3312,7 +3118,7 @@ void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = overright_value_span(Datum(ts_meos.value), span); free(span_data_copy); @@ -3331,7 +3137,7 @@ void SpanFunctions::Overright_value_span(DataChunk &args, ExpressionState &state // --- OPERATOR: span &> value --- void SpanFunctions::Overright_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan &> integer BinaryExecutor::Execute( @@ -3384,7 +3190,7 @@ void SpanFunctions::Overright_span_value(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } bool ret = overright_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -3403,7 +3209,7 @@ void SpanFunctions::Overright_span_value(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid DATESPAN data: null pointer"); + throw InvalidInputException("Invalid datespan data: null pointer"); } bool ret = overright_span_value(span, Datum(value)); free(span_data_copy); @@ -3423,7 +3229,7 @@ void SpanFunctions::Overright_span_value(DataChunk &args, ExpressionState &state Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } bool ret = overright_span_value(span, Datum(ts_meos.value)); free(span_data_copy); @@ -3476,7 +3282,7 @@ void SpanFunctions::Overright_span_span(DataChunk &args, ExpressionState &state, // --- SET OPERATOR --- void SpanFunctions::Union_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer + intspan BinaryExecutor::Execute( @@ -3542,7 +3348,7 @@ void SpanFunctions::Union_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } SpanSet *ret = union_value_span(Float8GetDatum(value), span); size_t span_size = sizeof(*ret); @@ -3595,7 +3401,7 @@ void SpanFunctions::Union_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } SpanSet *ret = union_value_span(Datum(ts_meos.value), span); size_t span_size = sizeof(*ret); @@ -3621,7 +3427,7 @@ void SpanFunctions::Union_value_span(DataChunk &args, ExpressionState &state, Ve void SpanFunctions::Union_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan + integer BinaryExecutor::Execute( @@ -3687,7 +3493,7 @@ void SpanFunctions::Union_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } SpanSet *ret = union_span_value(span, Float8GetDatum(value)); size_t span_size = sizeof(*ret); @@ -3740,7 +3546,7 @@ void SpanFunctions::Union_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } SpanSet *ret = union_span_value(span, Datum(ts_meos.value)); size_t span_size = sizeof(*ret); @@ -3802,7 +3608,7 @@ void SpanFunctions::Union_span_span(DataChunk &args, ExpressionState &state, Vec // --- OPERATOR: INTERSECTION --- void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer * intspan BinaryExecutor::Execute( @@ -3877,7 +3683,7 @@ void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &st Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } Span *ret = intersection_value_span(Float8GetDatum(value), span); if (!ret) { @@ -3938,7 +3744,7 @@ void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &st Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } Span *ret = intersection_value_span(Datum(ts_meos.value), span); if (!ret) { @@ -3967,7 +3773,7 @@ void SpanFunctions::Intersection_value_span(DataChunk &args, ExpressionState &st void SpanFunctions::Intersection_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan * integer BinaryExecutor::Execute( @@ -4042,7 +3848,7 @@ void SpanFunctions::Intersection_span_value(DataChunk &args, ExpressionState &st Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } Span *ret = intersection_span_value(span, Float8GetDatum(value)); if (!ret) { @@ -4103,7 +3909,7 @@ void SpanFunctions::Intersection_span_value(DataChunk &args, ExpressionState &st Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } Span *ret = intersection_span_value(span, Datum(ts_meos.value)); if (!ret) { @@ -4141,7 +3947,7 @@ void SpanFunctions::Intersection_span_span(DataChunk &args, ExpressionState &sta Span *span1 = reinterpret_cast(span1_data_copy); if (!span1) { free(span1_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } const uint8_t *span2_data = reinterpret_cast(span2_blob.GetData()); @@ -4151,7 +3957,7 @@ void SpanFunctions::Intersection_span_span(DataChunk &args, ExpressionState &sta Span *span2 = reinterpret_cast(span2_data_copy); if (!span2) { free(span2_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } Span *ret = intersection_span_span(span1, span2); @@ -4182,7 +3988,7 @@ void SpanFunctions::Intersection_span_span(DataChunk &args, ExpressionState &sta // --- OPERATOR: MINUS --- void SpanFunctions::Minus_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // integer - intspan BinaryExecutor::Execute( @@ -4257,7 +4063,7 @@ void SpanFunctions::Minus_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } SpanSet *ret = minus_value_span(Float8GetDatum(value), span); if (!ret) { @@ -4318,7 +4124,7 @@ void SpanFunctions::Minus_value_span(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } SpanSet *ret = minus_value_span(Datum(ts_meos.value), span); if (!ret) { @@ -4347,7 +4153,7 @@ void SpanFunctions::Minus_value_span(DataChunk &args, ExpressionState &state, Ve void SpanFunctions::Minus_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // intspan - integer BinaryExecutor::Execute( @@ -4422,7 +4228,7 @@ void SpanFunctions::Minus_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } SpanSet *ret = minus_span_value(span, Float8GetDatum(value)); if (!ret) { @@ -4483,7 +4289,7 @@ void SpanFunctions::Minus_span_value(DataChunk &args, ExpressionState &state, Ve Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } SpanSet *ret = minus_span_value(span, Datum(ts_meos.value)); if (!ret) { @@ -4521,7 +4327,7 @@ void SpanFunctions::Minus_span_span(DataChunk &args, ExpressionState &state, Vec Span *span1 = reinterpret_cast(span1_data_copy); if (!span1) { free(span1_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } const uint8_t *span2_data = reinterpret_cast(span2_blob.GetData()); @@ -4531,7 +4337,7 @@ void SpanFunctions::Minus_span_span(DataChunk &args, ExpressionState &state, Vec Span *span2 = reinterpret_cast(span2_data_copy); if (!span2) { free(span2_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } SpanSet *ret = minus_span_span(span1, span2); @@ -4562,7 +4368,7 @@ void SpanFunctions::Minus_span_span(DataChunk &args, ExpressionState &state, Vec //--- DISTANCE FUNCTIONS --- void SpanFunctions::Distance_span_value(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // distance between intspan and integer BinaryExecutor::Execute( @@ -4615,7 +4421,7 @@ void SpanFunctions::Distance_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } double distance = distance_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -4654,7 +4460,7 @@ void SpanFunctions::Distance_span_value(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } double secs = distance_span_timestamptz(span, (TimestampTz)ts_meos.value); free(span_data_copy); @@ -4673,7 +4479,7 @@ void SpanFunctions::Distance_span_value(DataChunk &args, ExpressionState &state, void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span_vec = args.data[1]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span_vec.GetType().GetAlias()); switch (span_type){ case T_INTSPAN: { // distance between integer and intspan BinaryExecutor::Execute( @@ -4726,7 +4532,7 @@ void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid FLOATSPAN data: null pointer"); + throw InvalidInputException("Invalid floatspan data: null pointer"); } double distance = distance_span_value(span, Float8GetDatum(value)); free(span_data_copy); @@ -4765,7 +4571,7 @@ void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, Span *span = reinterpret_cast(span_data_copy); if (!span) { free(span_data_copy); - throw InvalidInputException("Invalid TSTZSPAN data: null pointer"); + throw InvalidInputException("Invalid tstzspan data: null pointer"); } double secs = distance_span_timestamptz(span, (TimestampTz)ts_meos.value); free(span_data_copy); @@ -4783,7 +4589,7 @@ void SpanFunctions::Distance_value_span(DataChunk &args, ExpressionState &state, void SpanFunctions::Distance_span_span(DataChunk &args, ExpressionState &state, Vector &result) { auto &span1_vec = args.data[0]; - meosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span1_vec.GetType().GetAlias()); + MeosType span_type = SpanTypeMapping::GetMeosTypeFromAlias(span1_vec.GetType().GetAlias()); if (span_type == T_TSTZSPAN) { BinaryExecutor::ExecuteWithNulls( diff --git a/src/temporal/span_table_functions.cpp b/src/temporal/span_table_functions.cpp index 326f384d..e049201a 100644 --- a/src/temporal/span_table_functions.cpp +++ b/src/temporal/span_table_functions.cpp @@ -4,6 +4,7 @@ #include "temporal/span_table_functions.hpp" #include "temporal/spanset.hpp" #include "time_util.hpp" +#include "mobilityduck/meos_thread.hpp" #include "duckdb/common/exception.hpp" #include "duckdb/function/table_function.hpp" @@ -16,11 +17,11 @@ namespace { // Tag identifying the input span / spanset variant. Drives which MEOS // function the global-state init dispatches to. enum class BinsKind { - INTSPAN, - BIGINTSPAN, - FLOATSPAN, - DATESPAN, - TSTZSPAN, + intspan, + bigintspan, + floatspan, + datespan, + tstzspan, INTSPANSET, BIGINTSPANSET, FLOATSPANSET, @@ -44,7 +45,9 @@ struct BinsBindData : public FunctionData { r->blob = blob; r->vsize = vsize; r->vorigin = vorigin; - return unique_ptr(std::move(r)); + // DuckDB 1.4.4 disallows implicit derived->base unique_ptr conversion; + // explicit base-type construction from the moved-from derived pointer. + return unique_ptr_cast(std::move(r)); } bool Equals(const FunctionData &other_p) const override { auto &other = other_p.Cast(); @@ -67,6 +70,7 @@ struct BinsGlobalState : public GlobalTableFunctionState { }; static unique_ptr BinsInitGlobal(ClientContext &, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); auto &bind_data = input.bind_data->Cast(); auto state = make_uniq(); @@ -74,7 +78,7 @@ static unique_ptr BinsInitGlobal(ClientContext &, Tabl size_t raw_size = bind_data.blob.size(); switch (bind_data.kind) { - case BinsKind::INTSPAN: { + case BinsKind::intspan: { Span *s = reinterpret_cast(malloc(raw_size)); memcpy(s, raw_blob, raw_size); state->bins = intspan_bins(s, bind_data.vsize.GetValue(), @@ -82,7 +86,7 @@ static unique_ptr BinsInitGlobal(ClientContext &, Tabl free(s); break; } - case BinsKind::BIGINTSPAN: { + case BinsKind::bigintspan: { Span *s = reinterpret_cast(malloc(raw_size)); memcpy(s, raw_blob, raw_size); state->bins = bigintspan_bins(s, bind_data.vsize.GetValue(), @@ -90,7 +94,7 @@ static unique_ptr BinsInitGlobal(ClientContext &, Tabl free(s); break; } - case BinsKind::FLOATSPAN: { + case BinsKind::floatspan: { Span *s = reinterpret_cast(malloc(raw_size)); memcpy(s, raw_blob, raw_size); state->bins = floatspan_bins(s, bind_data.vsize.GetValue(), @@ -98,7 +102,7 @@ static unique_ptr BinsInitGlobal(ClientContext &, Tabl free(s); break; } - case BinsKind::DATESPAN: { + case BinsKind::datespan: { Span *s = reinterpret_cast(malloc(raw_size)); memcpy(s, raw_blob, raw_size); interval_t duck_duration = bind_data.vsize.GetValue(); @@ -108,7 +112,7 @@ static unique_ptr BinsInitGlobal(ClientContext &, Tabl free(s); break; } - case BinsKind::TSTZSPAN: { + case BinsKind::tstzspan: { Span *s = reinterpret_cast(malloc(raw_size)); memcpy(s, raw_blob, raw_size); interval_t duck_duration = bind_data.vsize.GetValue(); @@ -209,16 +213,16 @@ static unique_ptr BinsBind(ClientContext &, TableFunctionBindInput LogicalType span_out; switch (KIND) { - case BinsKind::INTSPAN: - case BinsKind::INTSPANSET: span_out = SpanTypes::INTSPAN(); break; - case BinsKind::BIGINTSPAN: - case BinsKind::BIGINTSPANSET: span_out = SpanTypes::BIGINTSPAN(); break; - case BinsKind::FLOATSPAN: - case BinsKind::FLOATSPANSET: span_out = SpanTypes::FLOATSPAN(); break; - case BinsKind::DATESPAN: - case BinsKind::DATESPANSET: span_out = SpanTypes::DATESPAN(); break; - case BinsKind::TSTZSPAN: - case BinsKind::TSTZSPANSET: span_out = SpanTypes::TSTZSPAN(); break; + case BinsKind::intspan: + case BinsKind::INTSPANSET: span_out = SpanTypes::intspan(); break; + case BinsKind::bigintspan: + case BinsKind::BIGINTSPANSET: span_out = SpanTypes::bigintspan(); break; + case BinsKind::floatspan: + case BinsKind::FLOATSPANSET: span_out = SpanTypes::floatspan(); break; + case BinsKind::datespan: + case BinsKind::DATESPANSET: span_out = SpanTypes::datespan(); break; + case BinsKind::tstzspan: + case BinsKind::TSTZSPANSET: span_out = SpanTypes::tstzspan(); break; } data->output_span_type = span_out; return_types.emplace_back(span_out); @@ -240,16 +244,16 @@ static TableFunction MakeBinsFunction(const LogicalType &input_type, const Logic void SpanTableFunctions::RegisterBins(ExtensionLoader &loader) { // span variants - loader.RegisterFunction(MakeBinsFunction( - SpanTypes::INTSPAN(), LogicalType::INTEGER, LogicalType::INTEGER)); - loader.RegisterFunction(MakeBinsFunction( - SpanTypes::BIGINTSPAN(), LogicalType::BIGINT, LogicalType::BIGINT)); - loader.RegisterFunction(MakeBinsFunction( - SpanTypes::FLOATSPAN(), LogicalType::DOUBLE, LogicalType::DOUBLE)); - loader.RegisterFunction(MakeBinsFunction( - SpanTypes::DATESPAN(), LogicalType::INTERVAL, LogicalType::DATE)); - loader.RegisterFunction(MakeBinsFunction( - SpanTypes::TSTZSPAN(), LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ)); + loader.RegisterFunction(MakeBinsFunction( + SpanTypes::intspan(), LogicalType::INTEGER, LogicalType::INTEGER)); + loader.RegisterFunction(MakeBinsFunction( + SpanTypes::bigintspan(), LogicalType::BIGINT, LogicalType::BIGINT)); + loader.RegisterFunction(MakeBinsFunction( + SpanTypes::floatspan(), LogicalType::DOUBLE, LogicalType::DOUBLE)); + loader.RegisterFunction(MakeBinsFunction( + SpanTypes::datespan(), LogicalType::INTERVAL, LogicalType::DATE)); + loader.RegisterFunction(MakeBinsFunction( + SpanTypes::tstzspan(), LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ)); // spanset variants loader.RegisterFunction(MakeBinsFunction( diff --git a/src/temporal/spanset.cpp b/src/temporal/spanset.cpp index dd3e42c0..e8759e02 100644 --- a/src/temporal/spanset.cpp +++ b/src/temporal/spanset.cpp @@ -19,146 +19,69 @@ extern "C" { namespace duckdb { -#define DEFINE_SPAN_SET_TYPE(NAME) \ - LogicalType SpansetTypes::NAME() { \ - auto type = LogicalType(LogicalTypeId::BLOB); \ - type.SetAlias(#NAME); \ - return type; \ - } - -DEFINE_SPAN_SET_TYPE(intspanset) -DEFINE_SPAN_SET_TYPE(bigintspanset) -DEFINE_SPAN_SET_TYPE(floatspanset) -DEFINE_SPAN_SET_TYPE(datespanset) -DEFINE_SPAN_SET_TYPE(tstzspanset) - -#undef DEFINE_SET_TYPE - -void SpansetTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "intspanset", intspanset()); - loader.RegisterType( "bigintspanset", bigintspanset()); - loader.RegisterType( "floatspanset", floatspanset()); - loader.RegisterType( "datespanset", datespanset()); - loader.RegisterType( "tstzspanset", tstzspanset()); -} - -const std::vector &SpansetTypes::AllTypes() { - static std::vector types = { - intspanset(), - bigintspanset(), - floatspanset(), - datespanset(), - tstzspanset() - }; - return types; -} - -meosType SpansetTypeMapping::GetMeosTypeFromAlias(const std::string &alias) { - static const std::unordered_map alias_to_type = { - {"intspanset", T_INTSPANSET}, - {"bigintspanset", T_BIGINTSPANSET}, - {"floatspanset", T_FLOATSPANSET}, - {"datespanset", T_DATESPANSET}, - {"tstzspanset", T_TSTZSPANSET} - }; - - auto it = alias_to_type.find(alias); - if (it != alias_to_type.end()) { - return it->second; - } else { - return T_UNKNOWN; - } -} - -LogicalType SpansetTypeMapping::GetChildType(const LogicalType &type) { - auto alias = type.ToString(); - if (alias == "intspanset") return SpanTypes::INTSPAN(); - if (alias == "bigintspanset") return SpanTypes::BIGINTSPAN(); - if (alias == "floatspanset") return SpanTypes::FLOATSPAN(); - if (alias == "datespanset") return SpanTypes::DATESPAN(); - if (alias == "tstzspanset") return SpanTypes::TSTZSPAN(); - throw NotImplementedException("GetChildType: unsupported alias: " + alias); -} - -LogicalType SpansetTypeMapping::GetSetType(const LogicalType &type) { - auto alias = type.ToString(); - if (alias == "intspanset") return SetTypes::intset(); - if (alias == "bigintspanset") return SetTypes::bigintset(); - if (alias == "floatspanset") return SetTypes::floatset(); - if (alias == "datespanset") return SetTypes::dateset(); - if (alias == "tstzspanset") return SetTypes::tstzset(); - throw NotImplementedException("GetChildType: unsupported alias: " + alias); -} - -LogicalType SpansetTypeMapping::GetBaseType(const LogicalType &type) { - auto alias = type.ToString(); - if (alias == "intspanset") return LogicalType::INTEGER; - if (alias == "bigintspanset") return LogicalType::BIGINT; - if (alias == "floatspanset") return LogicalType::DOUBLE; - if (alias == "datespanset") return LogicalType::DATE; - if (alias == "tstzspanset") return LogicalType::TIMESTAMP_TZ; - throw NotImplementedException("GetChildType: unsupported alias: " + alias); -} +// Collection type registration (accessors, RegisterTypes, AllTypes, alias->MeosType, +// GetChildType/GetSetType/GetBaseType) is generated from the catalog MeosType enum +// into src/generated/generated_type_registration.cpp. // --- Register Cast --- void SpansetTypes::RegisterCastFunctions(ExtensionLoader &loader) { for (const auto &spanset_type : SpansetTypes::AllTypes()) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, spanset_type, LogicalType::VARCHAR, SpansetFunctions::Spanset_to_text ); // Blob to text - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, spanset_type, SpansetFunctions::Text_to_spanset ); // text to blob auto base_type = SpansetTypeMapping::GetBaseType(spanset_type); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, base_type, spanset_type, SpansetFunctions::Value_to_spanset_cast ); auto set_type = SpansetTypeMapping::GetSetType(spanset_type); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, set_type, spanset_type, SpansetFunctions::Set_to_spanset_cast ); auto child_type = SpansetTypeMapping::GetChildType(spanset_type); // span - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, child_type, spanset_type, SpansetFunctions::Span_to_spanset_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, spanset_type, child_type, SpansetFunctions::Spanset_to_span_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::intspanset(), SpansetTypes::floatspanset(), SpansetFunctions::Intspanset_to_floatspanset_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::floatspanset(), SpansetTypes::intspanset(), SpansetFunctions::Floatspanset_to_intspanset_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::datespanset(), SpansetTypes::tstzspanset(), SpansetFunctions::Datespanset_to_tstzspanset_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::tstzspanset(), SpansetTypes::datespanset(), SpansetFunctions::Tstzspanset_to_datespanset_cast @@ -314,20 +237,9 @@ void SpansetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction("shiftScale", {spanset_type, LogicalType::DOUBLE, LogicalType::DOUBLE}, spanset_type, SpansetFunctions::Numspanset_shift_scale) ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("floor", {spanset_type}, spanset_type, SpansetFunctions::Floatspanset_floor) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ceil", {spanset_type}, spanset_type, SpansetFunctions::Floatspanset_ceil) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("round", {spanset_type}, spanset_type, SpansetFunctions::Floatspanset_round) - ); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("round", {spanset_type, LogicalType::INTEGER}, spanset_type, SpansetFunctions::Floatspanset_round) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {spanset_type}, spanset_type, SpansetFunctions::Floatspanset_degrees) - ); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {spanset_type}, spanset_type, SpansetFunctions::Floatspanset_radians) - ); - + // floor/ceil/round/degrees/radians on floatspanset are float-base scalar + // transforms generated from the catalog (generated_temporal_udfs.cpp), full + // arity plus the shorter DEFAULT-arg overload via sqlSignatures argDefaults. } else if( spanset_type == SpansetTypes::tstzspanset() ){ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("shift", {spanset_type, LogicalType::INTERVAL}, spanset_type, SpansetFunctions::Tstzspanset_shift) @@ -340,10 +252,8 @@ void SpansetTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ); } - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction("spans", {spanset_type}, LogicalType::LIST(child_type), SpansetFunctions::Spanset_spans) - ); - duckdb::RegisterSerializedScalarFunction(loader, + // spans() is generated from the catalog (spanset_spans) in generated_temporal_udfs.cpp. + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNSpans", {spanset_type, LogicalType::INTEGER}, LogicalType::LIST(child_type), SpansetFunctions::Spanset_split_n_spans) ); duckdb::RegisterSerializedScalarFunction(loader, diff --git a/src/temporal/spanset_functions.cpp b/src/temporal/spanset_functions.cpp index 4010f4d9..f81eaa7e 100644 --- a/src/temporal/spanset_functions.cpp +++ b/src/temporal/spanset_functions.cpp @@ -160,7 +160,7 @@ bool SpansetFunctions::Text_to_spanset(Vector &source, Vector &result, idx_t cou result.SetVectorType(VectorType::FLAT_VECTOR); auto target_type = result.GetType(); - meosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); + MeosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); UnaryExecutor::Execute( source, result, count, @@ -226,7 +226,7 @@ static inline void Write_spanset(Vector &result, idx_t row, SpanSet *s) { free(s); } -static inline void Value_to_spanset_core(Vector &source, Vector &result, idx_t count, meosType base_type) { +static inline void Value_to_spanset_core(Vector &source, Vector &result, idx_t count, MeosType base_type) { source.Flatten(count); result.SetVectorType(VectorType::FLAT_VECTOR); @@ -288,9 +288,9 @@ static inline void Value_to_spanset_core(Vector &source, Vector &result, idx_t c // --- CAST (conversion: base -> spanset) ---- bool SpansetFunctions::Value_to_spanset_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto target_type = result.GetType(); - meosType spanset_t = SpansetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); - meosType span_t = spansettype_spantype(spanset_t); - meosType base_t = spantype_basetype(span_t); + MeosType spanset_t = SpansetTypeMapping::GetMeosTypeFromAlias(target_type.GetAlias()); + MeosType span_t = spansettype_spantype(spanset_t); + MeosType base_t = spantype_basetype(span_t); Value_to_spanset_core(source, result, count, base_t); return true; @@ -300,9 +300,9 @@ bool SpansetFunctions::Value_to_spanset_cast(Vector &source, Vector &result, idx void SpansetFunctions::Value_to_spanset(DataChunk &args, ExpressionState &state, Vector &result) { auto &source = args.data[0]; auto out_type = result.GetType(); - meosType spanset_t= SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); - meosType span_t = spansettype_spantype(spanset_t); - meosType base_t = spantype_basetype(span_t); + MeosType spanset_t= SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType span_t = spansettype_spantype(spanset_t); + MeosType base_t = spantype_basetype(span_t); Value_to_spanset_core(source, result, args.size(), base_t); } @@ -824,8 +824,7 @@ void SpansetFunctions::Numspanset_width(DataChunk &args, ExpressionState &state, } auto blob = FlatVector::GetData(input_vec)[i]; - // Second argument registered as BOOLEAN; read as bool, not int32_t - // (see set_functions.cpp:Floatset_degrees for the same pattern). + // Second argument registered as BOOLEAN; read as bool, not int32_t. bool bools = has_bools ? FlatVector::GetData(*bools_vec_ptr)[i] : false; const uint8_t *data = (const uint8_t *)blob.GetData(); @@ -1161,7 +1160,7 @@ void SpansetFunctions::Tstzspanset_timestamps(DataChunk &args, ExpressionState & } static inline string_t Numspanset_shift_common(const string_t &blob, Datum shift_datum, - meosType validate_spanset_type, Vector &result) { + MeosType validate_spanset_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1208,7 +1207,7 @@ static inline string_t Tstzspanset_shift_common(const string_t &blob, interval_t void SpansetFunctions::Numspanset_shift(DataChunk &args, ExpressionState &state, Vector &result) { auto &spanset_vec = args.data[0]; auto out_type = result.GetType(); - meosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (spanset_type) { case T_INTSPANSET: { // shift(intspanset, integer) -> intspanset @@ -1262,7 +1261,7 @@ void SpansetFunctions::Tstzspanset_shift(DataChunk &args, ExpressionState &state } static inline string_t Numspanset_scale_common(const string_t &blob, Datum scale_datum, - meosType validate_spanset_type, Vector &result) { + MeosType validate_spanset_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1289,7 +1288,7 @@ static inline string_t Numspanset_scale_common(const string_t &blob, Datum scale void SpansetFunctions::Numspanset_scale(DataChunk &args, ExpressionState &state, Vector &result) { auto &spanset_vec = args.data[0]; auto out_type = result.GetType(); - meosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType spanset_type = SpansetTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (spanset_type) { case T_INTSPANSET: { // scale(intspanset, integer) -> intspanset @@ -1386,7 +1385,7 @@ static inline string_t Tstzspanset_shift_scale_common(const string_t &blob, inte } static inline string_t Numspanset_shift_scale_common(const string_t &blob, Datum shift_datum, Datum scale_datum, - meosType validate_spanset_type, Vector &result) { + MeosType validate_spanset_type, Vector &result) { const uint8_t *data = (const uint8_t *)blob.GetData(); size_t size = blob.GetSize(); @@ -1423,7 +1422,7 @@ static inline string_t Numspanset_shift_scale_common(const string_t &blob, Datum void SpansetFunctions::Numspanset_shift_scale(DataChunk &args, ExpressionState &state, Vector &result) { auto &spanset_vec = args.data[0]; auto out_type = result.GetType(); - meosType spanset_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); + MeosType spanset_type = SpanTypeMapping::GetMeosTypeFromAlias(out_type.GetAlias()); switch (spanset_type) { case T_INTSPANSET: { @@ -1479,203 +1478,10 @@ void SpansetFunctions::Tstzspanset_shift_scale(DataChunk &args, ExpressionState } } -void SpansetFunctions::Floatspanset_floor(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_floor(s); - free(s); - if (!r) { - throw InvalidInputException("floatspan_floor failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); -} +// floor/ceil/round/degrees/radians on floatspanset are generated from the catalog +// (generated_temporal_udfs.cpp); no hand bodies remain. -void SpansetFunctions::Floatspanset_ceil(DataChunk &args, ExpressionState &state, Vector &result) { - auto &input = args.data[0]; - UnaryExecutor::Execute( - input, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_ceil(s); - free(s); - if (!r) { - throw InvalidInputException("floatspan_ceil failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); -} - -void SpansetFunctions::Floatspanset_round(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(args.ColumnCount() == 1 || args.ColumnCount() == 2); - auto &args0 = args.data[0]; - Vector *args1 = args.ColumnCount() == 2 ? &args.data[1] : 0; - if (args.ColumnCount() == 2) { - BinaryExecutor::Execute( - args0, *args1, result, args.size(), - [&](string_t blob, int32_t precision) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_round(s, precision); - free(s); - if (!r) { - throw InvalidInputException("floatspanset_round failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } else { - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_round(s, 0); // default precision is 0 - free(s); - if (!r) { - throw InvalidInputException("floatspanset_round failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } -} - -void SpansetFunctions::Floatspanset_degrees(DataChunk &args, ExpressionState &state, Vector &result) { - D_ASSERT(args.ColumnCount() == 1|| args.ColumnCount() == 2); - auto &args0 = args.data[0]; - Vector *args1 = args.ColumnCount() == 2 ? &args.data[1] : 0; - if (args.ColumnCount() == 2) { - BinaryExecutor::Execute( - args0, *args1, result, args.size(), - [&](string_t blob, int32_t precision) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_degrees(s, precision); - free(s); - if (!r) { - throw InvalidInputException("floatspanset_degrees failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } else { - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_degrees(s, false); // default precision is false - free(s); - if (!r) { - throw InvalidInputException("floatspanset_degrees failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - } - -} - -void SpansetFunctions::Floatspanset_radians(DataChunk &args, ExpressionState &state, Vector &result) { - auto &args0 = args.data[0]; - UnaryExecutor::Execute( - args0, result, args.size(), - [&](string_t blob) -> string_t { - const uint8_t *data = (const uint8_t *)blob.GetData(); - size_t size = blob.GetSize(); - SpanSet *s = (SpanSet *)malloc(size); - memcpy(s, data, size); - VALIDATE_FLOATSPANSET(s, NULL); - SpanSet *r = floatspanset_radians(s); - if (!r) { - throw InvalidInputException("floatspanset_radians failed"); - } - string_t out = StringVector::AddStringOrBlob(result, (const char *)r, size); - free(r); - return out; - }); - -} - -void SpansetFunctions::Spanset_spans(DataChunk &args, ExpressionState &state, Vector &result) { - auto &spanset_vec = args.data[0]; - idx_t row_count = args.size(); - spanset_vec.Flatten(row_count); - - auto &result_validity = FlatVector::Validity(result); - auto list_entries = FlatVector::GetData(result); - auto &child_vector = ListVector::GetEntry(result); - child_vector.SetVectorType(VectorType::FLAT_VECTOR); - ListVector::Reserve(result, row_count); - - idx_t total_offset = 0; - const size_t span_bytes = sizeof(Span); - - for (idx_t i = 0; i < row_count; ++i) { - if (spanset_vec.GetValue(i).IsNull()) { - result_validity.SetInvalid(i); - continue; - } - - string_t blob = FlatVector::GetData(spanset_vec)[i]; - SpanSet *s = (SpanSet *)malloc(blob.GetSize()); - memcpy(s, blob.GetData(), blob.GetSize()); - - int num = spanset_num_spans(s); - Span *spans = spanset_spans(s); - free(s); - - if (!spans || num <= 0) { - result_validity.SetInvalid(i); - continue; - } - - ListVector::SetListSize(result, total_offset + num); - list_entries[i] = list_entry_t{total_offset, static_cast(num)}; - - auto *child_data = FlatVector::GetData(child_vector); - for (int j = 0; j < num; ++j) { - child_data[total_offset + j] = - StringVector::AddStringOrBlob(child_vector, reinterpret_cast(&spans[j]), span_bytes); - } - - free(spans); - total_offset += num; - result_validity.SetValid(i); - } -} +// spans() is generated from the catalog (spanset_spans) in generated_temporal_udfs.cpp. void SpansetFunctions::Spanset_split_n_spans(DataChunk &args, ExpressionState &state, Vector &result) { auto &spanset_vec = args.data[0]; auto &n_vec = args.data[1]; diff --git a/src/temporal/tbox.cpp b/src/temporal/tbox.cpp index 4e342038..f7f6ba1c 100644 --- a/src/temporal/tbox.cpp +++ b/src/temporal/tbox.cpp @@ -16,116 +16,116 @@ namespace duckdb { -LogicalType TboxType::TBOX() { +LogicalType TboxType::tbox() { LogicalType type(LogicalTypeId::BLOB); - type.SetAlias("TBOX"); + type.SetAlias("tbox"); return type; } void TboxType::RegisterType(ExtensionLoader &loader) { - loader.RegisterType( "TBOX", TBOX()); + loader.RegisterType( "tbox", tbox()); } void TboxType::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, - TBOX(), + tbox(), TboxFunctions::Tbox_in ); - loader.RegisterCastFunction( - TBOX(), + RegisterMeosCastFunction(loader, + tbox(), LogicalType::VARCHAR, TboxFunctions::Tbox_out ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::INTEGER, - TBOX(), + tbox(), TboxFunctions::Number_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::DOUBLE, - TBOX(), + tbox(), TboxFunctions::Number_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::TIMESTAMP_TZ, - TBOX(), + tbox(), TboxFunctions::Timestamptz_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::intset(), - TBOX(), + tbox(), TboxFunctions::Set_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::floatset(), - TBOX(), + tbox(), TboxFunctions::Set_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SetTypes::tstzset(), - TBOX(), + tbox(), TboxFunctions::Set_to_tbox_cast ); - loader.RegisterCastFunction( - SpanTypes::INTSPAN(), - TBOX(), + RegisterMeosCastFunction(loader, + SpanTypes::intspan(), + tbox(), TboxFunctions::Span_to_tbox_cast ); - loader.RegisterCastFunction( - SpanTypes::FLOATSPAN(), - TBOX(), + RegisterMeosCastFunction(loader, + SpanTypes::floatspan(), + tbox(), TboxFunctions::Span_to_tbox_cast ); - loader.RegisterCastFunction( - SpanTypes::TSTZSPAN(), - TBOX(), + RegisterMeosCastFunction(loader, + SpanTypes::tstzspan(), + tbox(), TboxFunctions::Span_to_tbox_cast ); - loader.RegisterCastFunction( - TBOX(), - SpanTypes::INTSPAN(), + RegisterMeosCastFunction(loader, + tbox(), + SpanTypes::intspan(), TboxFunctions::Tbox_to_intspan_cast ); - loader.RegisterCastFunction( - TBOX(), - SpanTypes::FLOATSPAN(), + RegisterMeosCastFunction(loader, + tbox(), + SpanTypes::floatspan(), TboxFunctions::Tbox_to_floatspan_cast ); - loader.RegisterCastFunction( - TBOX(), - SpanTypes::TSTZSPAN(), + RegisterMeosCastFunction(loader, + tbox(), + SpanTypes::tstzspan(), TboxFunctions::Tbox_to_tstzspan_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::intspanset(), - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::floatspanset(), - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox_cast ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, SpansetTypes::tstzspanset(), - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox_cast ); } @@ -135,7 +135,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {LogicalType::INTEGER, LogicalType::TIMESTAMP_TZ}, - TBOX(), + tbox(), TboxFunctions::Number_timestamptz_to_tbox ) ); @@ -144,7 +144,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {LogicalType::DOUBLE, LogicalType::TIMESTAMP_TZ}, - TBOX(), + tbox(), TboxFunctions::Number_timestamptz_to_tbox ) ); @@ -152,8 +152,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::INTSPAN(), LogicalType::TIMESTAMP_TZ}, - TBOX(), + {SpanTypes::intspan(), LogicalType::TIMESTAMP_TZ}, + tbox(), TboxFunctions::Numspan_timestamptz_to_tbox ) ); @@ -161,8 +161,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::FLOATSPAN(), LogicalType::TIMESTAMP_TZ}, - TBOX(), + {SpanTypes::floatspan(), LogicalType::TIMESTAMP_TZ}, + tbox(), TboxFunctions::Numspan_timestamptz_to_tbox ) ); @@ -170,8 +170,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {LogicalType::INTEGER, SpanTypes::TSTZSPAN()}, - TBOX(), + {LogicalType::INTEGER, SpanTypes::tstzspan()}, + tbox(), TboxFunctions::Number_tstzspan_to_tbox ) ); @@ -179,8 +179,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {LogicalType::DOUBLE, SpanTypes::TSTZSPAN()}, - TBOX(), + {LogicalType::DOUBLE, SpanTypes::tstzspan()}, + tbox(), TboxFunctions::Number_tstzspan_to_tbox ) ); @@ -188,8 +188,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::INTSPAN(), SpanTypes::TSTZSPAN()}, - TBOX(), + {SpanTypes::intspan(), SpanTypes::tstzspan()}, + tbox(), TboxFunctions::Numspan_tstzspan_to_tbox ) ); @@ -197,8 +197,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::FLOATSPAN(), SpanTypes::TSTZSPAN()}, - TBOX(), + {SpanTypes::floatspan(), SpanTypes::tstzspan()}, + tbox(), TboxFunctions::Numspan_tstzspan_to_tbox ) ); @@ -207,7 +207,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {LogicalType::INTEGER}, - TBOX(), + tbox(), TboxFunctions::Number_to_tbox ) ); @@ -216,7 +216,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {LogicalType::DOUBLE}, - TBOX(), + tbox(), TboxFunctions::Number_to_tbox ) ); @@ -225,7 +225,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {LogicalType::TIMESTAMP_TZ}, - TBOX(), + tbox(), TboxFunctions::Timestamptz_to_tbox ) ); @@ -234,7 +234,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SetTypes::intset()}, - TBOX(), + tbox(), TboxFunctions::Set_to_tbox ) ); @@ -243,7 +243,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SetTypes::floatset()}, - TBOX(), + tbox(), TboxFunctions::Set_to_tbox ) ); @@ -252,7 +252,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SetTypes::tstzset()}, - TBOX(), + tbox(), TboxFunctions::Set_to_tbox ) ); @@ -260,8 +260,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::INTSPAN()}, - TBOX(), + {SpanTypes::intspan()}, + tbox(), TboxFunctions::Span_to_tbox ) ); @@ -269,8 +269,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::FLOATSPAN()}, - TBOX(), + {SpanTypes::floatspan()}, + tbox(), TboxFunctions::Span_to_tbox ) ); @@ -278,8 +278,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox", - {SpanTypes::TSTZSPAN()}, - TBOX(), + {SpanTypes::tstzspan()}, + tbox(), TboxFunctions::Span_to_tbox ) ); @@ -287,8 +287,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "intspan", - {TBOX()}, - SpanTypes::INTSPAN(), + {tbox()}, + SpanTypes::intspan(), TboxFunctions::Tbox_to_intspan ) ); @@ -296,8 +296,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "floatspan", - {TBOX()}, - SpanTypes::FLOATSPAN(), + {tbox()}, + SpanTypes::floatspan(), TboxFunctions::Tbox_to_floatspan ) ); @@ -305,8 +305,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "timeSpan", - {TBOX()}, - SpanTypes::TSTZSPAN(), + {tbox()}, + SpanTypes::tstzspan(), TboxFunctions::Tbox_to_tstzspan ) ); @@ -315,7 +315,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SpansetTypes::intspanset()}, - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox ) ); @@ -324,7 +324,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SpansetTypes::floatspanset()}, - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox ) ); @@ -333,7 +333,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { ScalarFunction( "tbox", {SpansetTypes::tstzspanset()}, - TBOX(), + tbox(), TboxFunctions::Spanset_to_tbox ) ); @@ -341,7 +341,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "hasX", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_hasx ) @@ -350,7 +350,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "hasT", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_hast ) @@ -359,7 +359,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Xmin", - {TBOX()}, + {tbox()}, LogicalType::DOUBLE, TboxFunctions::Tbox_xmin ) @@ -368,7 +368,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "XminInc", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_xmin_inc ) @@ -377,7 +377,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Xmax", - {TBOX()}, + {tbox()}, LogicalType::DOUBLE, TboxFunctions::Tbox_xmax ) @@ -386,7 +386,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "XmaxInc", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_xmax_inc ) @@ -395,7 +395,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Tmin", - {TBOX()}, + {tbox()}, LogicalType::TIMESTAMP_TZ, TboxFunctions::Tbox_tmin ) @@ -404,7 +404,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "TminInc", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_tmin_inc ) @@ -413,7 +413,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "Tmax", - {TBOX()}, + {tbox()}, LogicalType::TIMESTAMP_TZ, TboxFunctions::Tbox_tmax ) @@ -422,7 +422,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "TmaxInc", - {TBOX()}, + {tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_tmax_inc ) @@ -431,8 +431,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftValue", - {TBOX(), LogicalType::INTEGER}, - TBOX(), + {tbox(), LogicalType::INTEGER}, + tbox(), TboxFunctions::Tbox_shift_value ) ); @@ -440,8 +440,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftValue", - {TBOX(), LogicalType::DOUBLE}, - TBOX(), + {tbox(), LogicalType::DOUBLE}, + tbox(), TboxFunctions::Tbox_shift_value ) ); @@ -449,8 +449,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftTime", - {TBOX(), LogicalType::INTERVAL}, - TBOX(), + {tbox(), LogicalType::INTERVAL}, + tbox(), TboxFunctions::Tbox_shift_time ) ); @@ -458,8 +458,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleValue", - {TBOX(), LogicalType::INTEGER}, - TBOX(), + {tbox(), LogicalType::INTEGER}, + tbox(), TboxFunctions::Tbox_scale_value ) ); @@ -467,8 +467,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleValue", - {TBOX(), LogicalType::DOUBLE}, - TBOX(), + {tbox(), LogicalType::DOUBLE}, + tbox(), TboxFunctions::Tbox_scale_value ) ); @@ -476,8 +476,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "scaleTime", - {TBOX(), LogicalType::INTERVAL}, - TBOX(), + {tbox(), LogicalType::INTERVAL}, + tbox(), TboxFunctions::Tbox_scale_time ) ); @@ -485,8 +485,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleValue", - {TBOX(), LogicalType::INTEGER, LogicalType::INTEGER}, - TBOX(), + {tbox(), LogicalType::INTEGER, LogicalType::INTEGER}, + tbox(), TboxFunctions::Tbox_shift_scale_value ) ); @@ -494,8 +494,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleValue", - {TBOX(), LogicalType::DOUBLE, LogicalType::DOUBLE}, - TBOX(), + {tbox(), LogicalType::DOUBLE, LogicalType::DOUBLE}, + tbox(), TboxFunctions::Tbox_shift_scale_value ) ); @@ -503,8 +503,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftScaleTime", - {TBOX(), LogicalType::INTERVAL, LogicalType::INTERVAL}, - TBOX(), + {tbox(), LogicalType::INTERVAL, LogicalType::INTERVAL}, + tbox(), TboxFunctions::Tbox_shift_scale_time ) ); @@ -512,8 +512,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "expandValue", - {TBOX(), LogicalType::INTEGER}, - TBOX(), + {tbox(), LogicalType::INTEGER}, + tbox(), TboxFunctions::Tbox_expand_value ) ); @@ -521,8 +521,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "expandValue", - {TBOX(), LogicalType::DOUBLE}, - TBOX(), + {tbox(), LogicalType::DOUBLE}, + tbox(), TboxFunctions::Tbox_expand_value ) ); @@ -530,8 +530,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "expandTime", - {TBOX(), LogicalType::INTERVAL}, - TBOX(), + {tbox(), LogicalType::INTERVAL}, + tbox(), TboxFunctions::Tbox_expand_time ) ); @@ -539,8 +539,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "round", - {TBOX()}, - TBOX(), + {tbox()}, + tbox(), TboxFunctions::Tbox_round ) ); @@ -548,8 +548,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "round", - {TBOX(), LogicalType::INTEGER}, - TBOX(), + {tbox(), LogicalType::INTEGER}, + tbox(), TboxFunctions::Tbox_round ) ); @@ -557,7 +557,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_contains", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Contains_tbox_tbox ) @@ -566,7 +566,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "@>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Contains_tbox_tbox ) @@ -575,7 +575,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_contained", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Contained_tbox_tbox ) @@ -584,7 +584,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<@", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Contained_tbox_tbox ) @@ -593,7 +593,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_overlaps", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overlaps_tbox_tbox ) @@ -602,7 +602,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&&", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overlaps_tbox_tbox ) @@ -611,7 +611,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_same", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Same_tbox_tbox ) @@ -620,7 +620,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "~=", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Same_tbox_tbox ) @@ -629,7 +629,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_adjacent", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Adjacent_tbox_tbox ) @@ -638,7 +638,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "-|-", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Adjacent_tbox_tbox ) @@ -647,7 +647,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_left", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Left_tbox_tbox ) @@ -656,7 +656,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<<", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Left_tbox_tbox ) @@ -665,7 +665,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_overleft", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overleft_tbox_tbox ) @@ -674,7 +674,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&<", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overleft_tbox_tbox ) @@ -683,7 +683,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_right", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Right_tbox_tbox ) @@ -692,7 +692,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Right_tbox_tbox ) @@ -701,7 +701,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_overright", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overright_tbox_tbox ) @@ -710,7 +710,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overright_tbox_tbox ) @@ -719,7 +719,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_before", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Before_tbox_tbox ) @@ -728,7 +728,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<<#", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Before_tbox_tbox ) @@ -737,7 +737,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_overbefore", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overbefore_tbox_tbox ) @@ -748,7 +748,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "&<#", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overbefore_tbox_tbox ) @@ -757,7 +757,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_after", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::After_tbox_tbox ) @@ -766,7 +766,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "#>>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::After_tbox_tbox ) @@ -775,7 +775,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_overafter", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overafter_tbox_tbox ) @@ -784,7 +784,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "#&>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Overafter_tbox_tbox ) @@ -793,8 +793,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_union", - {TBOX(), TBOX()}, - TBOX(), + {tbox(), tbox()}, + tbox(), TboxFunctions::Union_tbox_tbox ) ); @@ -802,8 +802,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_intersection", - {TBOX(), TBOX()}, - TBOX(), + {tbox(), tbox()}, + tbox(), TboxFunctions::Intersection_tbox_tbox ) ); @@ -811,8 +811,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "+", - {TBOX(), TBOX()}, - TBOX(), + {tbox(), tbox()}, + tbox(), TboxFunctions::Union_tbox_tbox ) ); @@ -820,8 +820,8 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "*", - {TBOX(), TBOX()}, - TBOX(), + {tbox(), tbox()}, + tbox(), TboxFunctions::Intersection_tbox_tbox ) ); @@ -829,7 +829,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_eq", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_eq ) @@ -838,7 +838,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_ne", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_ne ) @@ -847,7 +847,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_lt", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_lt ) @@ -856,7 +856,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_le", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_le ) @@ -865,7 +865,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_ge", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_ge ) @@ -873,7 +873,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_gt", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_gt ) @@ -882,7 +882,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tbox_cmp", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::INTEGER, TboxFunctions::Tbox_cmp ) @@ -891,7 +891,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "=", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_eq ) @@ -900,7 +900,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<>", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_ne ) @@ -909,7 +909,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_lt ) @@ -918,7 +918,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "<=", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_le ) @@ -927,7 +927,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">=", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_ge ) @@ -935,7 +935,7 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( ">", - {TBOX(), TBOX()}, + {tbox(), tbox()}, LogicalType::BOOLEAN, TboxFunctions::Tbox_gt ) @@ -945,22 +945,22 @@ void TboxType::RegisterScalarFunctions(ExtensionLoader &loader) { * WKB / hex-WKB serialization + hashing ****************************************************/ duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "asBinary", {TBOX()}, LogicalType::BLOB, + "asBinary", {tbox()}, LogicalType::BLOB, TboxFunctions::Tbox_as_wkb)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "asHexWKB", {TBOX()}, LogicalType::VARCHAR, + "asHexWKB", {tbox()}, LogicalType::VARCHAR, TboxFunctions::Tbox_as_hexwkb)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "tboxFromBinary", {LogicalType::BLOB}, TBOX(), + "tboxFromBinary", {LogicalType::BLOB}, tbox(), TboxFunctions::Tbox_from_wkb)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "tboxFromHexWKB", {LogicalType::VARCHAR}, TBOX(), + "tboxFromHexWKB", {LogicalType::VARCHAR}, tbox(), TboxFunctions::Tbox_from_hexwkb)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "tbox_hash", {TBOX()}, LogicalType::INTEGER, + "tbox_hash", {tbox()}, LogicalType::INTEGER, TboxFunctions::Tbox_hash)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( - "tbox_hash_extended", {TBOX(), LogicalType::BIGINT}, LogicalType::BIGINT, + "tbox_hash_extended", {tbox(), LogicalType::BIGINT}, LogicalType::BIGINT, TboxFunctions::Tbox_hash_extended)); } diff --git a/src/temporal/tbox_functions.cpp b/src/temporal/tbox_functions.cpp index fd17bacf..7507bc61 100644 --- a/src/temporal/tbox_functions.cpp +++ b/src/temporal/tbox_functions.cpp @@ -84,7 +84,7 @@ bool TboxFunctions::Tbox_out(Vector &source, Vector &result, idx_t count, CastPa } template -void TboxFunctions::NumberTimestamptzToTboxExecutor(Vector &value, Vector &t, meosType basetype, Vector &result, idx_t count) { +void TboxFunctions::NumberTimestamptzToTboxExecutor(Vector &value, Vector &t, MeosType basetype, Vector &result, idx_t count) { BinaryExecutor::Execute( value, t, result, count, [&](TA value, timestamp_tz_t t) { @@ -150,7 +150,7 @@ void TboxFunctions::Numspan_timestamptz_to_tbox(DataChunk &args, ExpressionState } template -void TboxFunctions::NumberTstzspanToTboxExecutor(Vector &value, Vector &span_str, meosType basetype, Vector &result, idx_t count) { +void TboxFunctions::NumberTstzspanToTboxExecutor(Vector &value, Vector &span_str, MeosType basetype, Vector &result, idx_t count) { BinaryExecutor::Execute( value, span_str, result, count, [&](TA value, string_t span_str) { @@ -234,7 +234,7 @@ void TboxFunctions::Numspan_tstzspan_to_tbox(DataChunk &args, ExpressionState &s } template -void TboxFunctions::NumberToTboxExecutor(Vector &value, meosType basetype, Vector &result, idx_t count) { +void TboxFunctions::NumberToTboxExecutor(Vector &value, MeosType basetype, Vector &result, idx_t count) { UnaryExecutor::Execute( value, result, count, [&](TA value) { @@ -1007,7 +1007,7 @@ void TboxFunctions::Tbox_shift_scale_time(DataChunk &args, ExpressionState &stat } template -void TboxFunctions::TboxExpandValueExecutor(Vector &tbox, Vector &value, meosType basetype, Vector &result, idx_t count) { +void TboxFunctions::TboxExpandValueExecutor(Vector &tbox, Vector &value, MeosType basetype, Vector &result, idx_t count) { BinaryExecutor::ExecuteWithNulls( tbox, value, result, count, [&](string_t tbox_str, TB value, ValidityMask &mask, idx_t idx) { diff --git a/src/temporal/temporal.cpp b/src/temporal/temporal.cpp index 108210bb..cb9bdc36 100644 --- a/src/temporal/temporal.cpp +++ b/src/temporal/temporal.cpp @@ -34,26 +34,29 @@ namespace duckdb { return type; \ } -DEFINE_TEMPORAL_TYPE(TINT) -DEFINE_TEMPORAL_TYPE(TBOOL) -DEFINE_TEMPORAL_TYPE(TFLOAT) -DEFINE_TEMPORAL_TYPE(TTEXT) +DEFINE_TEMPORAL_TYPE(tint) +DEFINE_TEMPORAL_TYPE(tbigint) +DEFINE_TEMPORAL_TYPE(tbool) +DEFINE_TEMPORAL_TYPE(tfloat) +DEFINE_TEMPORAL_TYPE(ttext) #undef DEFINE_TEMPORAL_TYPE void TemporalTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TINT", TINT()); - loader.RegisterType( "TBOOL", TBOOL()); - loader.RegisterType( "TFLOAT", TFLOAT()); - loader.RegisterType( "TTEXT", TTEXT()); + loader.RegisterType( "tint", tint()); + loader.RegisterType( "tbigint", tbigint()); + loader.RegisterType( "tbool", tbool()); + loader.RegisterType( "tfloat", tfloat()); + loader.RegisterType( "ttext", ttext()); } const std::vector &TemporalTypes::AllTypes() { static std::vector types = { - TINT(), - TBOOL(), - TFLOAT(), - TTEXT() + tint(), + tbigint(), + tbool(), + tfloat(), + ttext() }; return types; } @@ -69,13 +72,13 @@ LogicalType TemporalTypes::GetBaseTypeFromAlias(const char *alias) { void TemporalTypes::RegisterCastFunctions(ExtensionLoader &loader) { for (auto &type : TemporalTypes::AllTypes()) { - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::VARCHAR, type, TemporalFunctions::Temporal_in ); - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, type, LogicalType::VARCHAR, TemporalFunctions::Temporal_out @@ -90,39 +93,39 @@ void TemporalTypes::RegisterCastFunctions(ExtensionLoader &loader) { // ); // } - loader.RegisterCastFunction( + RegisterMeosCastFunction(loader, LogicalType::BLOB, SpansetTypes::tstzspanset(), TemporalFunctions::Blob_to_tstzspanset ); - loader.RegisterCastFunction( - TemporalTypes::TBOOL(), - TemporalTypes::TINT(), + RegisterMeosCastFunction(loader, + TemporalTypes::tbool(), + TemporalTypes::tint(), TemporalFunctions::Tbool_to_tint_cast ); - loader.RegisterCastFunction( - TemporalTypes::TINT(), - TemporalTypes::TFLOAT(), + RegisterMeosCastFunction(loader, + TemporalTypes::tint(), + TemporalTypes::tfloat(), TemporalFunctions::Tint_to_tfloat_cast ); - loader.RegisterCastFunction( - TemporalTypes::TFLOAT(), - TemporalTypes::TINT(), + RegisterMeosCastFunction(loader, + TemporalTypes::tfloat(), + TemporalTypes::tint(), TemporalFunctions::Tfloat_to_tint_cast ); - loader.RegisterCastFunction( - TemporalTypes::TINT(), - TboxType::TBOX(), + RegisterMeosCastFunction(loader, + TemporalTypes::tint(), + TboxType::tbox(), TemporalFunctions::Tnumber_to_tbox_cast ); - loader.RegisterCastFunction( - TemporalTypes::TFLOAT(), - TboxType::TBOX(), + RegisterMeosCastFunction(loader, + TemporalTypes::tfloat(), + TboxType::tbox(), TemporalFunctions::Tnumber_to_tbox_cast ); @@ -160,7 +163,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( StringUtil::Lower(type.GetAlias()), - {TemporalTypes::GetBaseTypeFromAlias(type.GetAlias().c_str()), SpanTypes::TSTZSPAN()}, + {TemporalTypes::GetBaseTypeFromAlias(type.GetAlias().c_str()), SpanTypes::tstzspan()}, type, TemporalFunctions::Tsequence_from_base_tstzspan ) @@ -168,7 +171,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( StringUtil::Lower(type.GetAlias()), - {TemporalTypes::GetBaseTypeFromAlias(type.GetAlias().c_str()), SpanTypes::TSTZSPAN(), LogicalType::VARCHAR}, + {TemporalTypes::GetBaseTypeFromAlias(type.GetAlias().c_str()), SpanTypes::tstzspan(), LogicalType::VARCHAR}, type, TemporalFunctions::Tsequence_from_base_tstzspan ) @@ -216,7 +219,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // the helper and the explanation of the 1.4 type-check bug it // fixes. - if (type.GetAlias() != "TBOOL") { + if (type.GetAlias() != "tbool") { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minInstant", @@ -316,98 +319,6 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {LogicalType::LIST(type)}, - type, - TemporalFunctions::Tsequence_constructor - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {LogicalType::LIST(type), LogicalType::VARCHAR}, - type, - TemporalFunctions::Tsequence_constructor - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {LogicalType::LIST(type), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - type, - TemporalFunctions::Tsequence_constructor - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Inst", - {type}, - type, - TemporalFunctions::Temporal_to_tinstant - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {LogicalType::LIST(type), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - type, - TemporalFunctions::Tsequence_constructor - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {type, LogicalType::VARCHAR}, - type, - TemporalFunctions::Temporal_to_tsequence - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "Seq", - {type}, - type, - TemporalFunctions::Temporal_to_tsequence - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "SeqSet", - {LogicalType::LIST(type)}, - type, - TemporalFunctions::Tsequenceset_constructor - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "SeqSet", - {type}, - type, - TemporalFunctions::Temporal_to_tsequenceset - ) - ); - - if (type.GetAlias() == "TFLOAT") { - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - StringUtil::Lower(type.GetAlias()) + "SeqSet", - {type, LogicalType::VARCHAR}, - type, - TemporalFunctions::Temporal_to_tsequenceset - ) - ); - } - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "setInterp", @@ -462,26 +373,11 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timeSpan", - {type}, - SpanTypes::TSTZSPAN(), - TemporalFunctions::Temporal_to_tstzspan - ) - ); - - if (type.GetAlias() == "TINT") { - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "valueSpan", - {type}, - SpanTypes::INTSPAN(), - TemporalFunctions::Tnumber_to_span - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, + // timeSpan/valueSpan (temporal_to_tstzspan / tnumber_to_span, group + // meos_temporal_conversion) are generated from the catalog sqlSignatures + // in src/generated/generated_temporal_udfs.cpp (RETIRED_GROUPS). + if (type.GetAlias() == "tint") { + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueSet", {type}, @@ -489,17 +385,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { TemporalFunctions::Temporal_valueset ) ); - } else if (type.GetAlias() == "TFLOAT") { - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "valueSpan", - {type}, - SpanTypes::FLOATSPAN(), - TemporalFunctions::Tnumber_to_span - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, + } else if (type.GetAlias() == "tfloat") { + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "valueSet", {type}, @@ -545,14 +432,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "timestamps", - {type}, - LogicalType::LIST(LogicalType::TIMESTAMP_TZ), - TemporalFunctions::Temporal_timestamps - ) - ); + // timestamps() is generated from the catalog (temporal_timestamps) in generated_temporal_udfs.cpp. duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( @@ -575,7 +455,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atTime", - {type, SpanTypes::TSTZSPAN()}, + {type, SpanTypes::tstzspan()}, type, TemporalFunctions::Temporal_at_tstzspan ) @@ -620,7 +500,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusTime", - {type, SpanTypes::TSTZSPAN()}, + {type, SpanTypes::tstzspan()}, type, TemporalFunctions::Temporal_minus_tstzspan ) @@ -644,7 +524,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ) ); - if (type.GetAlias() == "TINT" || type.GetAlias() == "TFLOAT") { + if (type.GetAlias() == "tint" || type.GetAlias() == "tfloat") { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "shiftValue", @@ -690,7 +570,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { ) ); } - if (type.GetAlias() != "TBOOL") { + if (type.GetAlias() != "tbool") { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "tempDump", @@ -828,7 +708,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {type, SpanTypes::TSTZSPAN()}, + {type, SpanTypes::tstzspan()}, type, TemporalFunctions::Temporal_delete_tstzspan ) @@ -836,7 +716,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "deleteTime", - {type, SpanTypes::TSTZSPAN(), LogicalType::BOOLEAN}, + {type, SpanTypes::tstzspan(), LogicalType::BOOLEAN}, type, TemporalFunctions::Temporal_delete_tstzspan ) @@ -1000,7 +880,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } // Typed `getValue` / `startValue` / `endValue` / `minValue` / `maxValue` - // overloads for TINT, TBOOL, TFLOAT. Each registration pairs the input + // overloads for tint, tbool, tfloat. Each registration pairs the input // temporal-type alias with the C++ scalar result type so the generated // DuckDB result Vector type matches what the MEOS accessor actually // writes, which DuckDB 1.4's UnaryExecutor asserts strictly. See the @@ -1011,92 +891,43 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // getValue(tint / tbool / tfloat) — instant-level accessor mobilityduck::RegisterTemporalDatumAccessor( - loader, "getValue", TemporalTypes::TINT(), LogicalType::BIGINT, tinstant_value_temporal); + loader, "getValue", TemporalTypes::tint(), LogicalType::BIGINT, tinstant_value_temporal); mobilityduck::RegisterTemporalDatumAccessor( - loader, "getValue", TemporalTypes::TBOOL(), LogicalType::BOOLEAN, tinstant_value_temporal); + loader, "getValue", TemporalTypes::tbool(), LogicalType::BOOLEAN, tinstant_value_temporal); mobilityduck::RegisterTemporalDatumAccessor( - loader, "getValue", TemporalTypes::TFLOAT(), LogicalType::DOUBLE, tinstant_value_temporal); + loader, "getValue", TemporalTypes::tfloat(), LogicalType::DOUBLE, tinstant_value_temporal); - // startValue / endValue on TINT / TBOOL / TFLOAT - mobilityduck::RegisterTemporalDatumAccessor( - loader, "startValue", TemporalTypes::TINT(), LogicalType::BIGINT, temporal_start_value); + // startValue / endValue on tbool / tfloat. The tint overloads are now owned by + // the generated surface (canonical INTEGER return, per the catalog `int` — not + // the legacy hand BIGINT); kept here only for the types the generated marshalling + // matches identically (tbool->BOOLEAN, tfloat->DOUBLE). mobilityduck::RegisterTemporalDatumAccessor( - loader, "startValue", TemporalTypes::TBOOL(), LogicalType::BOOLEAN, temporal_start_value); + loader, "startValue", TemporalTypes::tbool(), LogicalType::BOOLEAN, temporal_start_value); mobilityduck::RegisterTemporalDatumAccessor( - loader, "startValue", TemporalTypes::TFLOAT(), LogicalType::DOUBLE, temporal_start_value); + loader, "startValue", TemporalTypes::tfloat(), LogicalType::DOUBLE, temporal_start_value); - mobilityduck::RegisterTemporalDatumAccessor( - loader, "endValue", TemporalTypes::TINT(), LogicalType::BIGINT, temporal_end_value); mobilityduck::RegisterTemporalDatumAccessor( - loader, "endValue", TemporalTypes::TBOOL(), LogicalType::BOOLEAN, temporal_end_value); + loader, "endValue", TemporalTypes::tbool(), LogicalType::BOOLEAN, temporal_end_value); mobilityduck::RegisterTemporalDatumAccessor( - loader, "endValue", TemporalTypes::TFLOAT(), LogicalType::DOUBLE, temporal_end_value); + loader, "endValue", TemporalTypes::tfloat(), LogicalType::DOUBLE, temporal_end_value); - // minValue / maxValue on TINT / TFLOAT (TBOOL omitted — min/max on a - // boolean is meaningless and the existing API does not expose it) - mobilityduck::RegisterTemporalDatumAccessor( - loader, "minValue", TemporalTypes::TINT(), LogicalType::BIGINT, temporal_min_value); + // minValue / maxValue on tfloat (tint owned by the generated INTEGER surface; + // tbool omitted — min/max on a boolean is meaningless and the API omits it) mobilityduck::RegisterTemporalDatumAccessor( - loader, "minValue", TemporalTypes::TFLOAT(), LogicalType::DOUBLE, temporal_min_value); + loader, "minValue", TemporalTypes::tfloat(), LogicalType::DOUBLE, temporal_min_value); - mobilityduck::RegisterTemporalDatumAccessor( - loader, "maxValue", TemporalTypes::TINT(), LogicalType::BIGINT, temporal_max_value); mobilityduck::RegisterTemporalDatumAccessor( - loader, "maxValue", TemporalTypes::TFLOAT(), LogicalType::DOUBLE, temporal_max_value); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "atValues", - {TemporalTypes::TINT(), SetTypes::intset()}, - TemporalTypes::TINT(), - TemporalFunctions::Temporal_at_values - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "atValues", - {TemporalTypes::TFLOAT(), SetTypes::floatset()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Temporal_at_values - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "atValues", - {TemporalTypes::TTEXT(), SetTypes::textset()}, - TemporalTypes::TTEXT(), - TemporalFunctions::Temporal_at_values - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "minusValues", - {TemporalTypes::TINT(), SetTypes::intset()}, - TemporalTypes::TINT(), - TemporalFunctions::Temporal_minus_value - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "minusValues", - {TemporalTypes::TFLOAT(), SetTypes::floatset()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Temporal_minus_value - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "minusValues", - {TemporalTypes::TTEXT(), SetTypes::textset()}, - TemporalTypes::TTEXT(), - TemporalFunctions::Temporal_minus_value - ) - ); - duckdb::RegisterSerializedScalarFunction(loader, + loader, "maxValue", TemporalTypes::tfloat(), LogicalType::DOUBLE, temporal_max_value); + + // atValues / minusValues (Temporal, set-of-T) are now generated from the catalog + // (temporal_at_values / temporal_minus_values, sqlSignatures-driven) — see + // src/generated/generated_temporal_udfs.cpp. Behaviour-equivalent to the retired hand + // regs (both call the MEOS set restriction), and the generated surface adds the + // previously-missing tbigint overload. + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "whenTrue", - {TemporalTypes::TBOOL()}, + {TemporalTypes::tbool()}, SpansetTypes::tstzspanset(), TemporalFunctions::Tbool_when_true ) @@ -1105,8 +936,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TemporalTypes::TINT(), SpanTypes::INTSPAN()}, - TemporalTypes::TINT(), + {TemporalTypes::tint(), SpanTypes::intspan()}, + TemporalTypes::tint(), TemporalFunctions::Tnumber_at_span ) ); @@ -1114,8 +945,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TemporalTypes::TFLOAT(), SpanTypes::FLOATSPAN()}, - TemporalTypes::TFLOAT(), + {TemporalTypes::tfloat(), SpanTypes::floatspan()}, + TemporalTypes::tfloat(), TemporalFunctions::Tnumber_at_span ) ); @@ -1123,8 +954,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TemporalTypes::TINT(), SpanTypes::INTSPAN()}, - TemporalTypes::TINT(), + {TemporalTypes::tint(), SpanTypes::intspan()}, + TemporalTypes::tint(), TemporalFunctions::Tnumber_minus_span ) ); @@ -1132,8 +963,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TemporalTypes::TFLOAT(), SpanTypes::FLOATSPAN()}, - TemporalTypes::TFLOAT(), + {TemporalTypes::tfloat(), SpanTypes::floatspan()}, + TemporalTypes::tfloat(), TemporalFunctions::Tnumber_minus_span ) ); @@ -1141,8 +972,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TemporalTypes::TINT(), SpansetTypes::intspanset()}, - TemporalTypes::TINT(), + {TemporalTypes::tint(), SpansetTypes::intspanset()}, + TemporalTypes::tint(), TemporalFunctions::Tnumber_at_spanset ) ); @@ -1150,8 +981,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "atValues", - {TemporalTypes::TFLOAT(), SpansetTypes::floatspanset()}, - TemporalTypes::TFLOAT(), + {TemporalTypes::tfloat(), SpansetTypes::floatspanset()}, + TemporalTypes::tfloat(), TemporalFunctions::Tnumber_at_spanset ) ); @@ -1159,8 +990,8 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TemporalTypes::TINT(), SpansetTypes::intspanset()}, - TemporalTypes::TINT(), + {TemporalTypes::tint(), SpansetTypes::intspanset()}, + TemporalTypes::tint(), TemporalFunctions::Tnumber_minus_spanset ) ); @@ -1168,115 +999,32 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "minusValues", - {TemporalTypes::TFLOAT(), SpansetTypes::floatspanset()}, - TemporalTypes::TFLOAT(), + {TemporalTypes::tfloat(), SpansetTypes::floatspanset()}, + TemporalTypes::tfloat(), TemporalFunctions::Tnumber_minus_spanset ) ); - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "atTbox", - {TemporalTypes::TINT(), TboxType::TBOX()}, - TemporalTypes::TINT(), - TemporalFunctions::Tnumber_at_tbox - ) - ); + // atTbox / minusTbox (TNumber, tbox) are now generated from the catalog + // (tnumber_at_tbox / tnumber_minus_tbox, sqlSignatures-driven) — see + // src/generated/generated_temporal_udfs.cpp. Behaviour-equivalent to the retired hand + // regs (both call the MEOS box restriction), and the generated surface adds the + // previously-missing tbigint overload. - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "atTbox", - {TemporalTypes::TFLOAT(), TboxType::TBOX()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Tnumber_at_tbox - ) - ); + // round(tfloat) and round(tfloat, integer) are float-base scalar transforms + // generated from the catalog (generated_temporal_udfs.cpp): the shorter + // DEFAULT-arg overload comes from sqlSignatures argDefaults. - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "minusTbox", - {TemporalTypes::TINT(), TboxType::TBOX()}, - TemporalTypes::TINT(), - TemporalFunctions::Tnumber_minus_tbox - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "minusTbox", - {TemporalTypes::TFLOAT(), TboxType::TBOX()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Tnumber_minus_tbox - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TemporalTypes::TFLOAT()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Temporal_round - ) - ); + // The temporal-number casts (tint/tfloat) and tbox() conversion function forms + // (tbool_to_tint / tint_to_tfloat / tfloat_to_tint / tnumber_to_tbox, group + // meos_temporal_conversion) are generated from the catalog sqlSignatures in + // src/generated/generated_temporal_udfs.cpp (RETIRED_GROUPS) — incl the tbigint + // overloads the hand layer was missing. - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "round", - {TemporalTypes::TFLOAT(), LogicalType::INTEGER}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Temporal_round - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tint", - {TemporalTypes::TBOOL()}, - TemporalTypes::TINT(), - TemporalFunctions::Tbool_to_tint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tfloat", - {TemporalTypes::TINT()}, - TemporalTypes::TFLOAT(), - TemporalFunctions::Tint_to_tfloat - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tint", - {TemporalTypes::TFLOAT()}, - TemporalTypes::TINT(), - TemporalFunctions::Tfloat_to_tint - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tbox", - {TemporalTypes::TINT()}, - TboxType::TBOX(), - TemporalFunctions::Tnumber_to_tbox - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, - ScalarFunction( - "tbox", - {TemporalTypes::TFLOAT()}, - TboxType::TBOX(), - TemporalFunctions::Tnumber_to_tbox - ) - ); - - duckdb::RegisterSerializedScalarFunction(loader, + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getValues", - {TemporalTypes::TINT()}, + {TemporalTypes::tint()}, SpansetTypes::intspanset(), TemporalFunctions::Tnumber_valuespans ) @@ -1285,7 +1033,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "getValues", - {TemporalTypes::TFLOAT()}, + {TemporalTypes::tfloat()}, SpansetTypes::floatspanset(), TemporalFunctions::Tnumber_valuespans ) @@ -1294,7 +1042,7 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "avgValue", - {TemporalTypes::TINT()}, + {TemporalTypes::tint()}, LogicalType::DOUBLE, TemporalFunctions::Tnumber_avg_value ) @@ -1303,106 +1051,93 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction( "avgValue", - {TemporalTypes::TFLOAT()}, + {TemporalTypes::tfloat()}, LogicalType::DOUBLE, TemporalFunctions::Tnumber_avg_value ) ); // tbool boolean operators - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::TBOOL(), LogicalType::BOOLEAN}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {LogicalType::BOOLEAN, TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::TBOOL(), TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_tbool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::TBOOL(), LogicalType::BOOLEAN}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {LogicalType::BOOLEAN, TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::TBOOL(), TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_tbool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~", {TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tnot_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), TemporalFunctions::Tand_tbool_bool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tand_bool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tand_tbool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), TemporalFunctions::Tor_tbool_bool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tor_bool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("|", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tor_tbool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~", {TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tnot_tbool)); // Portable-SQL aliases (MobilityDB names): tbool_and / tbool_or / tbool_not - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {TemporalTypes::TBOOL(), LogicalType::BOOLEAN}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {LogicalType::BOOLEAN, TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {TemporalTypes::TBOOL(), TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tand_tbool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {TemporalTypes::TBOOL(), LogicalType::BOOLEAN}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {LogicalType::BOOLEAN, TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {TemporalTypes::TBOOL(), TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tor_tbool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_not", {TemporalTypes::TBOOL()}, TemporalTypes::TBOOL(), TemporalFunctions::Tnot_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), TemporalFunctions::Tand_tbool_bool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tand_bool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_and", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tand_tbool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {TemporalTypes::tbool(), LogicalType::BOOLEAN}, TemporalTypes::tbool(), TemporalFunctions::Tor_tbool_bool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {LogicalType::BOOLEAN, TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tor_bool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_or", {TemporalTypes::tbool(), TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tor_tbool_tbool)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tbool_not", {TemporalTypes::tbool()}, TemporalTypes::tbool(), TemporalFunctions::Tnot_tbool)); // tnumber arithmetic operators - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Add_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Add_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Add_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Sub_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Sub_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Sub_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Mult_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Mult_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Mult_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Div_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Div_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Div_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_tnumber_tnumber)); - - // Unary tnumber functions - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("abs", {TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Tnumber_abs)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("abs", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tnumber_abs)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("derivative", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Temporal_derivative)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_degrees)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("degrees", {TemporalTypes::TFLOAT(), LogicalType::BOOLEAN}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_degrees)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("radians", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_radians)); - - // Unary tfloat math functions - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("exp", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_exp)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ln", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_ln)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("log10", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tfloat_log10)); - - // deltaValue / trend on tnumber - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("deltaValue", {TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Tnumber_delta_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("deltaValue", {TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tnumber_delta_value)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("trend", {TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Tnumber_trend)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("trend", {TemporalTypes::TFLOAT()}, TemporalTypes::TINT(), TemporalFunctions::Tnumber_trend)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Add_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Add_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Add_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Add_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Add_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("+", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Add_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Sub_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Sub_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Sub_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Sub_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Sub_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Sub_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Mult_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Mult_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Mult_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Mult_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Mult_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("*", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Mult_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Div_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Div_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Div_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Div_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Div_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("/", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Div_tnumber_tnumber)); + + // Unary tfloat transforms floor/ceil/round/degrees/radians are float-base scalar + // transforms generated from the catalog (generated_temporal_udfs.cpp), full arity + // plus the shorter DEFAULT-arg overload via sqlSignatures argDefaults. + // The meos_temporal_math group (abs/derivative/exp/ln/log10/deltaValue/trend) is + // supplied by the generated surface (RETIRED_GROUPS in the codegen). // Named-function aliases for the arithmetic operators (MobilityDB exposes // both `+`/`-`/`*`/`/` and `tnumber_add`/`sub`/`mult`/`div`). - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Add_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Add_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Add_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Add_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Sub_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Sub_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Sub_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Sub_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Mult_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Mult_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Mult_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Mult_tnumber_tnumber)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {LogicalType::INTEGER, TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Div_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::TINT(), LogicalType::INTEGER}, TemporalTypes::TINT(), TemporalFunctions::Div_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Div_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Div_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Add_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Add_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Add_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Add_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Add_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_add", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Add_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Sub_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Sub_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Sub_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Sub_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Sub_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_sub", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Sub_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Mult_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Mult_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Mult_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Mult_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Mult_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_mult", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Mult_tnumber_tnumber)); + + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {LogicalType::INTEGER, TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Div_int_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::tint(), LogicalType::INTEGER}, TemporalTypes::tint(), TemporalFunctions::Div_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {LogicalType::DOUBLE, TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Div_float_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TemporalTypes::tfloat(), TemporalFunctions::Div_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::tint(), TemporalTypes::tint()}, TemporalTypes::tint(), TemporalFunctions::Div_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tnumber_div", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Div_tnumber_tnumber)); // tnumber distance and nearest-approach-distance. // @@ -1415,182 +1150,53 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // SELECT 100.0::DOUBLE <-> tfloat '2.5@2000-01-01'; -- returns 2.5, expected 97.5 // The temporal-temporal variant DOES work correctly, and so does nad_*. // Restore the value-distance registrations once the MEOS issue is resolved. - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Tdistance_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tdistance_tnumber_tnumber)); + // The (tint,tint) temporal distance is owned by the generated surface, which + // returns a tfloat (the temporal distance is always a tfloat — the hand line + // wrongly typed the result BLOB as tint). The tfloat,tfloat variant matches the + // generated return and is kept. + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<->", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Tdistance_tnumber_tnumber)); // Named form of the same function for SQL portability. - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tdistance", {TemporalTypes::TINT(), TemporalTypes::TINT()}, TemporalTypes::TINT(), TemporalFunctions::Tdistance_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tdistance", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, TemporalTypes::TFLOAT(), TemporalFunctions::Tdistance_tnumber_tnumber)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tdistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, TemporalTypes::tfloat(), TemporalFunctions::Tdistance_tnumber_tnumber)); // nearestApproachDistance / nad — scalar return - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::TINT(), LogicalType::INTEGER}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::TINT(), TemporalTypes::TINT()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::TINT(), LogicalType::INTEGER}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::TINT(), TemporalTypes::TINT()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat)); - - // Temporal topological predicates: temporal × temporal (5 ops × 4 type pairs). - // Each operator also registers the matching `temporal_*` named alias. - for (auto &t1 : TemporalTypes::AllTypes()) { - for (auto &t2 : TemporalTypes::AllTypes()) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Contains_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Contained_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Same_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Same_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Contains_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Contained_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_temporal_temporal)); - } - } - // Temporal × tstzspan (and the reverse direction) - for (auto &t : TemporalTypes::AllTypes()) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Contains_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Contained_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Same_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Same_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Contains_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Contained_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_temporal_tstzspan)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Same_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Same_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tstzspan_temporal)); - } - - // Temporal time-position predicates registered as named functions: - // DuckDB's parser does not accept `#` as an operator-name character, - // so the upstream MobilityDB operators `<<#`, `#>>`, `&<#`, `#&>` - // are unreachable from SQL. The named-function forms `before`, - // `after`, `overbefore`, `overafter` provide equivalent behaviour. - for (auto &t1 : TemporalTypes::AllTypes()) { - for (auto &t2 : TemporalTypes::AllTypes()) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("before", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("after", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_before", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_after", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overbefore",{t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overafter", {t1, t2}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_temporal)); - } - } - for (auto &t : TemporalTypes::AllTypes()) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("before", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("after", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_before", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_after", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overbefore",{t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overafter", {t, SpanTypes::TSTZSPAN()}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_tstzspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("before", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Before_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("after", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::After_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overbefore", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("overafter", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_before", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Before_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_after", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::After_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overbefore",{SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_tstzspan_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overafter", {SpanTypes::TSTZSPAN(), t}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_tstzspan_temporal)); - } - - // Same time-position predicates extended to tgeompoint (× tstzspan and - // × tgeompoint). MEOS dispatches by Temporal* so the same C wrappers work. - { - auto tg = TgeompointType::TGEOMPOINT(); - auto tspan = SpanTypes::TSTZSPAN(); - loader.RegisterFunction(ScalarFunction("before", {tg, tspan}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_tstzspan)); - loader.RegisterFunction(ScalarFunction("after", {tg, tspan}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_tstzspan)); - loader.RegisterFunction(ScalarFunction("overbefore", {tg, tspan}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_tstzspan)); - loader.RegisterFunction(ScalarFunction("overafter", {tg, tspan}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_tstzspan)); - loader.RegisterFunction(ScalarFunction("before", {tspan, tg}, LogicalType::BOOLEAN, TemporalFunctions::Before_tstzspan_temporal)); - loader.RegisterFunction(ScalarFunction("after", {tspan, tg}, LogicalType::BOOLEAN, TemporalFunctions::After_tstzspan_temporal)); - loader.RegisterFunction(ScalarFunction("overbefore", {tspan, tg}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_tstzspan_temporal)); - loader.RegisterFunction(ScalarFunction("overafter", {tspan, tg}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_tstzspan_temporal)); - loader.RegisterFunction(ScalarFunction("before", {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::Before_temporal_temporal)); - loader.RegisterFunction(ScalarFunction("after", {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::After_temporal_temporal)); - loader.RegisterFunction(ScalarFunction("overbefore", {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::Overbefore_temporal_temporal)); - loader.RegisterFunction(ScalarFunction("overafter", {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::Overafter_temporal_temporal)); - } + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_int)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat)); + + // Temporal topological predicates (contains/contained/overlaps/same/adjacent + + // @>/<@/&&/~=/-|-) for temporal × temporal (same base family) and temporal × + // tstzspan (both directions) are generated from the catalog sqlSignatures in + // src/generated/generated_temporal_udfs.cpp (@ingroup meos_temporal_bbox_topo). + // The non-canonical temporal_* snake aliases and the spurious mixed-family + // cross-product overloads are dropped (bare same-family names supersede them). + + // Temporal time-position predicates (before/after/overbefore/overafter for + // temporal×temporal, temporal×tstzspan both directions, and tgeompoint; + // @ingroup meos_temporal_bbox_pos) are generated from the catalog sqlSignatures + // in src/generated/generated_temporal_udfs.cpp. DuckDB's parser rejects `#` in + // operator names, so only the named forms are reachable — the generator emits + // exactly those, same-base-family per the catalog (no spurious mixed pairs). + // The stale-snake temporal_* aliases are dropped (bare names supersede them). // Ever / always equality and inequality (named functions; DuckDB // parser does not accept ?= / #= operator names). -#define REG_EA(NAME, FN) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {LogicalType::BOOLEAN, TemporalTypes::TBOOL()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_bool_tbool)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TBOOL(), LogicalType::BOOLEAN}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tbool_bool)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {LogicalType::INTEGER, TemporalTypes::TINT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_int_tint)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TINT(), LogicalType::INTEGER}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tint_int)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_float_tfloat)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tfloat_float)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TINT(), TemporalTypes::TINT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_temporal_temporal)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_temporal_temporal)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TBOOL(), TemporalTypes::TBOOL()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_temporal_temporal)); - - REG_EA("ever_eq", Ever_eq) - REG_EA("always_eq", Always_eq) - REG_EA("ever_ne", Ever_ne) - REG_EA("always_ne", Always_ne) -#undef REG_EA - - // Ordering ever/always — no tbool variant (booleans have no ordering) -#define REG_EA_ORD(NAME, FN) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {LogicalType::INTEGER, TemporalTypes::TINT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_int_tint)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TINT(), LogicalType::INTEGER}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tint_int)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {LogicalType::DOUBLE, TemporalTypes::TFLOAT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_float_tfloat)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tfloat_float)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TINT(), TemporalTypes::TINT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_temporal_temporal)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(NAME, {TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT()}, LogicalType::BOOLEAN, TemporalFunctions::FN##_temporal_temporal)); - - REG_EA_ORD("ever_lt", Ever_lt) - REG_EA_ORD("always_lt", Always_lt) - REG_EA_ORD("ever_le", Ever_le) - REG_EA_ORD("always_le", Always_le) - REG_EA_ORD("ever_gt", Ever_gt) - REG_EA_ORD("always_gt", Always_gt) - REG_EA_ORD("ever_ge", Ever_ge) - REG_EA_ORD("always_ge", Always_ge) -#undef REG_EA_ORD - - // Similarity measures (tnumber × tnumber, tgeompoint × tgeompoint) - for (auto &t : {TemporalTypes::TINT(), TemporalTypes::TFLOAT()}) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {t, t}, LogicalType::DOUBLE, TemporalFunctions::Temporal_frechet_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("discreteFrechet", {t, t}, LogicalType::DOUBLE, TemporalFunctions::Temporal_frechet_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarp", {t, t}, LogicalType::DOUBLE, TemporalFunctions::Temporal_dyntimewarp_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpDistance", {t, t}, LogicalType::DOUBLE, TemporalFunctions::Temporal_dyntimewarp_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {t, t}, LogicalType::DOUBLE, TemporalFunctions::Temporal_hausdorff_distance)); - auto path_type = LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistancePath", {t, t}, path_type, TemporalFunctions::Temporal_frechet_path)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpPath", {t, t}, path_type, TemporalFunctions::Temporal_dyntimewarp_path)); - } - // similarity on tgeompoint (including paths) - { - auto tg = TgeompointType::TGEOMPOINT(); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistance", {tg, tg}, LogicalType::DOUBLE, TemporalFunctions::Temporal_frechet_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("discreteFrechet", {tg, tg}, LogicalType::DOUBLE, TemporalFunctions::Temporal_frechet_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarp", {tg, tg}, LogicalType::DOUBLE, TemporalFunctions::Temporal_dyntimewarp_distance)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("hausdorffDistance", {tg, tg}, LogicalType::DOUBLE, TemporalFunctions::Temporal_hausdorff_distance)); - auto path_type = LogicalType::LIST(LogicalType::STRUCT({{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}})); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("frechetDistancePath", {tg, tg}, path_type, TemporalFunctions::Temporal_frechet_path)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("dynTimeWarpPath", {tg, tg}, path_type, TemporalFunctions::Temporal_dyntimewarp_path)); - } + // Traditional/ever/always temporal comparisons (meos_temporal_comp_ever) are + // supplied by the generated surface (RETIRED_GROUPS). The spatial (geometry-arg) + // ever/always overloads remain hand-registered in the geo module. + + // Similarity: frechetDistance/dynTimeWarpDistance/hausdorffDistance (scalar) and + // frechetDistancePath/dynTimeWarpPath (SETOF -> DuckDB table function) are all GENERATED + // from the catalog now. The non-canonical discreteFrechet/dynTimeWarp hand aliases were + // retired (MobilityDB canonical = frechetDistance/dynTimeWarpDistance). // simplify family (subtype-agnostic but only meaningful on linear temporal types) - for (const auto &t : {TemporalTypes::TFLOAT(), TgeompointType::TGEOMPOINT(), - TGeometryTypes::TGEOMETRY()}) { + for (const auto &t : {TemporalTypes::tfloat(), TgeompointType::tgeompoint(), + TGeometryTypes::tgeometry()}) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("douglasPeuckerSimplify", {t, LogicalType::DOUBLE}, t, TemporalFunctions::Temporal_simplify_dp)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("douglasPeuckerSimplify", @@ -1608,222 +1214,13 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { TemporalFunctions::Temporal_simplify_min_tdelta)); } - // tnumber × {numspan, tbox} topological predicates (4 ops × 8 shape pairs) - { - auto tint = TemporalTypes::TINT(); - auto tflt = TemporalTypes::TFLOAT(); - auto ispan = SpanTypes::INTSPAN(); - auto fspan = SpanTypes::FLOATSPAN(); - auto tbox = TboxType::TBOX(); - - // tnumber × numspan (5 ops each: @>, <@, &&, ~=, -|-) - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_numspan)); - // numspan × tnumber - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Contains_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Contained_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Same_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Same_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Contains_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Contained_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Contains_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Contained_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Same_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Same_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Contains_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Contained_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_numspan_tnumber)); - // tnumber × tbox - for (auto &t : {tint, tflt}) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Same_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Same_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_same", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Same_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contains", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Contains_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_contained", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Contained_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overlaps", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overlaps_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_adjacent", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Adjacent_tbox_tnumber)); - } - - // Position ops (<<, >>, &<, &>) — same surface - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Left_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Right_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overright_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Left_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Right_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overright_numspan_tnumber)); - for (auto &t : {tint, tflt}) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Left_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Right_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tbox_tnumber)); - } - // tnumber × tnumber (same base type) - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("<<", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(">>", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&<", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("&>", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tnumber)); - - // Named aliases for numeric-axis position predicates - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {tint, ispan}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {tflt, fspan}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_numspan)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Left_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Right_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {ispan, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overright_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Left_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Right_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_numspan_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {fspan, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overright_numspan_tnumber)); - for (auto &t : {tint, tflt}) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {t, tbox}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tbox)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Left_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Right_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tbox_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {tbox, t}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tbox_tnumber)); - } - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {tint, tint}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_left", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Left_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_right", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Right_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overleft", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overleft_tnumber_tnumber)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_overright", {tflt, tflt}, LogicalType::BOOLEAN, TemporalFunctions::Overright_tnumber_tnumber)); - } - - // Temporal comparison predicates returning tbool (temporal_teq/tne/tlt/tle/tgt/tge) - { - auto tbool = TemporalTypes::TBOOL(); - auto tint = TemporalTypes::TINT(); - auto tflt = TemporalTypes::TFLOAT(); - auto ttext = TemporalTypes::TTEXT(); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {LogicalType::BOOLEAN, tbool}, tbool, TemporalFunctions::Teq_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tbool, LogicalType::BOOLEAN}, tbool, TemporalFunctions::Teq_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Teq_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Teq_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Teq_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Teq_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Teq_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Teq_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tint, tint}, tbool, TemporalFunctions::Teq_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tflt, tflt}, tbool, TemporalFunctions::Teq_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_teq", {tbool, tbool}, tbool, TemporalFunctions::Teq_temporal_temporal)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {LogicalType::BOOLEAN, tbool}, tbool, TemporalFunctions::Tne_bool_tbool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tbool, LogicalType::BOOLEAN}, tbool, TemporalFunctions::Tne_tbool_bool)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Tne_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Tne_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Tne_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Tne_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Tne_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Tne_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tint, tint}, tbool, TemporalFunctions::Tne_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tflt, tflt}, tbool, TemporalFunctions::Tne_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tne", {tbool, tbool}, tbool, TemporalFunctions::Tne_temporal_temporal)); - - // temporal_tlt/tle/tgt/tge: ordered types only (int, float, text) - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Tlt_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Tlt_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Tlt_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Tlt_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Tlt_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Tlt_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {tint, tint}, tbool, TemporalFunctions::Tlt_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tlt", {tflt, tflt}, tbool, TemporalFunctions::Tlt_temporal_temporal)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Tle_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Tle_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Tle_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Tle_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Tle_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Tle_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {tint, tint}, tbool, TemporalFunctions::Tle_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tle", {tflt, tflt}, tbool, TemporalFunctions::Tle_temporal_temporal)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Tgt_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Tgt_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Tgt_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Tgt_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Tgt_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Tgt_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {tint, tint}, tbool, TemporalFunctions::Tgt_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tgt", {tflt, tflt}, tbool, TemporalFunctions::Tgt_temporal_temporal)); - - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {LogicalType::INTEGER, tint}, tbool, TemporalFunctions::Tge_int_tint)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {tint, LogicalType::INTEGER}, tbool, TemporalFunctions::Tge_tint_int)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {LogicalType::DOUBLE, tflt}, tbool, TemporalFunctions::Tge_float_tfloat)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {tflt, LogicalType::DOUBLE}, tbool, TemporalFunctions::Tge_tfloat_float)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {LogicalType::VARCHAR, ttext}, tbool, TemporalFunctions::Tge_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {ttext, LogicalType::VARCHAR}, tbool, TemporalFunctions::Tge_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {tint, tint}, tbool, TemporalFunctions::Tge_temporal_temporal)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_tge", {tflt, tflt}, tbool, TemporalFunctions::Tge_temporal_temporal)); - } + // tnumber × {numspan, tbox} topological predicates (contains/contained/overlaps/ + // same/adjacent + @>/<@/&&/~=/-|-, both directions) are generated from the catalog + // sqlSignatures (@ingroup meos_temporal_bbox_topo); the temporal_* snake aliases + // are dropped. The numeric-axis positional predicates are likewise generated. + // Temporal #= comparison (temporal_teq/tne/tlt/tle/tgt/tge) is generated + // (group meos_temporal_comp_temp). // tprecision and tsample — time-domain rebinning for (auto &t : TemporalTypes::AllTypes()) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tprecision", {t, LogicalType::INTERVAL}, t, TemporalFunctions::Temporal_tprecision)); @@ -1833,81 +1230,42 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tsample", {t, LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR}, t, TemporalFunctions::Temporal_tsample)); } - // tboxes / splitNTboxes / splitEachNTboxes — tnumber → LIST(TBOX) + // tboxes / splitNTboxes / splitEachNTboxes — tnumber → LIST(tbox) { - auto tbox_list = LogicalType::LIST(TboxType::TBOX()); - for (auto &t : {TemporalTypes::TINT(), TemporalTypes::TFLOAT()}) { - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tboxes", {t}, tbox_list, TemporalFunctions::Tnumber_tboxes)); + auto tbox_list = LogicalType::LIST(TboxType::tbox()); + // tboxes() is generated from the catalog (tnumber_tboxes) in generated_temporal_udfs.cpp. + for (auto &t : {TemporalTypes::tint(), TemporalTypes::tfloat()}) { duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitNTboxes", {t, LogicalType::INTEGER}, tbox_list, TemporalFunctions::Tnumber_split_n_tboxes)); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("splitEachNTboxes", {t, LogicalType::INTEGER}, tbox_list, TemporalFunctions::Tnumber_split_each_n_tboxes)); } } - // tspatial × {stbox, tspatial} position predicates. - // - // For each direction (left/right/below/above/front/back and the over* - // variants, plus the time-axis before/after/overbefore/overafter), the - // predicate is registered both as the operator form (where DuckDB's - // parser accepts the token, only L/R for now: <<, >>, &<, &>) and as - // both the bare named form (left/right/below/above/front/back/before/ - // after/overbelow/overabove/overfront/overback/overbefore/overafter) - // and the MobilityDB-canonical `temporal_*` alias. - { - auto tg = TgeompointType::TGEOMPOINT(); - auto stbox = StboxType::STBOX(); - -#define REG_TSPATIAL_OP(SQL_NAME, ALIAS, FN) \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(SQL_NAME, {tg, stbox}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tspatial_stbox)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(ALIAS, {tg, stbox}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tspatial_stbox)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(SQL_NAME, {stbox, tg}, LogicalType::BOOLEAN, TemporalFunctions::FN##_stbox_tspatial)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(ALIAS, {stbox, tg}, LogicalType::BOOLEAN, TemporalFunctions::FN##_stbox_tspatial)); \ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(SQL_NAME, {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tspatial_tspatial));\ - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction(ALIAS, {tg, tg}, LogicalType::BOOLEAN, TemporalFunctions::FN##_tspatial_tspatial)); - - // L/R as both operator and named alias (DuckDB accepts <<, >>, &<, &> tokens) - REG_TSPATIAL_OP("<<", "temporal_left", Left) - REG_TSPATIAL_OP(">>", "temporal_right", Right) - REG_TSPATIAL_OP("&<", "temporal_overleft", Overleft) - REG_TSPATIAL_OP("&>", "temporal_overright", Overright) - - // Vertical / Z-axis as named only (DuckDB rejects <<|, |>>, /<<, >>/, etc.) - REG_TSPATIAL_OP("below", "temporal_below", Below) - REG_TSPATIAL_OP("above", "temporal_above", Above) - REG_TSPATIAL_OP("front", "temporal_front", Front) - REG_TSPATIAL_OP("back", "temporal_back", Back) - REG_TSPATIAL_OP("overbelow", "temporal_overbelow", Overbelow) - REG_TSPATIAL_OP("overabove", "temporal_overabove", Overabove) - REG_TSPATIAL_OP("overfront", "temporal_overfront", Overfront) - REG_TSPATIAL_OP("overback", "temporal_overback", Overback) - - // Time-axis on tspatial as named only (DuckDB rejects <<#, #>>, &<#, #&>) - REG_TSPATIAL_OP("before", "temporal_before", Before) - REG_TSPATIAL_OP("after", "temporal_after", After) - REG_TSPATIAL_OP("overbefore", "temporal_overbefore", Overbefore) - REG_TSPATIAL_OP("overafter", "temporal_overafter", Overafter) - -#undef REG_TSPATIAL_OP - } + // tspatial × {stbox, tspatial} position predicates (spatial axes + // left/right/below/above/front/back + over*, and the time axis before/after/ + // overbefore/overafter; @ingroup meos_geo_box_pos / meos_geo_bbox_pos) — bare + // names AND the <<, >>, &<, &> operator forms — are generated from the catalog + // sqlSignatures in src/generated/generated_temporal_udfs.cpp. The stale-snake + // temporal_* aliases are dropped (bare names supersede them). // ttext text functions - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Ttext_lower)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Ttext_upper)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("initcap", {TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Ttext_initcap)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {LogicalType::VARCHAR, TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::TTEXT(), LogicalType::VARCHAR}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::TTEXT(), TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_ttext_ttext)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_lower)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_upper)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("initcap", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_initcap)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_text_ttext)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_text)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_ttext)); // Portable-SQL alias (MobilityDB name): ttext_cat - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {LogicalType::VARCHAR, TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_text_ttext)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {TemporalTypes::TTEXT(), LogicalType::VARCHAR}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_ttext_text)); - duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {TemporalTypes::TTEXT(), TemporalTypes::TTEXT()}, TemporalTypes::TTEXT(), TemporalFunctions::Textcat_ttext_ttext)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_text_ttext)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_text)); + duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("ttext_cat", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_ttext)); } struct TemporalUnnestBindData : public TableFunctionData { string_t blob; - meosType temptype; + MeosType temptype; LogicalType returnType; - TemporalUnnestBindData(string_t blob, meosType temptype, LogicalType returnType) + TemporalUnnestBindData(string_t blob, MeosType temptype, LogicalType returnType) : blob(std::move(blob)), temptype(temptype), returnType(std::move(returnType)) {} }; @@ -1942,6 +1300,7 @@ static unique_ptr TemporalUnnestBind(ClientContext &context, static unique_ptr TemporalUnnestInit(ClientContext &context, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); auto &bind = input.bind_data->Cast(); auto &blob = bind.blob; @@ -2015,7 +1374,7 @@ static void TemporalUnnestExec(ClientContext &context, TableFunctionInput &input void TemporalTypes::RegisterTemporalUnnestFunction(ExtensionLoader &loader) { for (auto &type : TemporalTypes::AllTypes()) { - if (type.GetAlias() != "TBOOL") { + if (type.GetAlias() != "tbool") { TableFunction fn("tempUnnest", {type}, TemporalUnnestExec, @@ -2029,7 +1388,7 @@ void TemporalTypes::RegisterTemporalUnnestFunction(ExtensionLoader &loader) { // ─── portable WKB I/O for scalar temporal types ────────────────────────────── // Uses temporal_as_wkb / temporal_from_wkb (type-agnostic MEOS functions) to // produce the same MEOS-WKB bytes that tgeompoint's asBinary/tgeompointFromBinary -// already use. Adding these overloads gives TINT / TFLOAT / TBOOL / TTEXT the +// already use. Adding these overloads gives tint / tfloat / tbool / ttext the // same Parquet-round-trip story as spatial temporals. namespace { @@ -2081,64 +1440,19 @@ void TemporalScalarFromWkbExec(DataChunk &args, ExpressionState &, Vector &resul }); } -void TemporalScalarFromHexWkbExec(DataChunk &args, ExpressionState &, Vector &result) { - UnaryExecutor::Execute( - args.data[0], result, args.size(), - [&](string_t input) -> string_t { - std::string hex(input.GetData(), input.GetSize()); - Temporal *t = temporal_from_hexwkb(hex.c_str()); - if (!t) throw InvalidInputException( - "fromHexWKB: invalid hex-encoded MEOS-WKB"); - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; - }); -} - -template -void TemporalScalarFromMfjsonExec(DataChunk &args, ExpressionState &, Vector &result) { - UnaryExecutor::Execute( - args.data[0], result, args.size(), - [&](string_t input) -> string_t { - std::string mfj(input.GetData(), input.GetSize()); - Temporal *t = FN(mfj.c_str()); - if (!t) throw InvalidInputException( - "fromMFJSON: invalid MFJSON input"); - size_t sz = temporal_mem_size(t); - string_t stored = StringVector::AddStringOrBlob( - result, string_t(reinterpret_cast(t), sz)); - free(t); - return stored; - }); -} - } // anonymous namespace void TemporalTypes::RegisterWkbFunctions(ExtensionLoader &loader) { const auto B = LogicalType::BLOB; - const auto V = LogicalType::VARCHAR; struct Entry { LogicalType type; const char *bin_name; - const char *hex_name; - const char *mfj_name; - scalar_function_t mfj_exec; }; const Entry types[] = { - { TINT(), "tintFromBinary", - "tintFromHexWKB", "tintFromMFJSON", - TemporalScalarFromMfjsonExec<&tint_from_mfjson> }, - { TFLOAT(), "tfloatFromBinary", - "tfloatFromHexWKB", "tfloatFromMFJSON", - TemporalScalarFromMfjsonExec<&tfloat_from_mfjson> }, - { TBOOL(), "tboolFromBinary", - "tboolFromHexWKB", "tboolFromMFJSON", - TemporalScalarFromMfjsonExec<&tbool_from_mfjson> }, - { TTEXT(), "ttextFromBinary", - "ttextFromHexWKB", "ttextFromMFJSON", - TemporalScalarFromMfjsonExec<&ttext_from_mfjson> }, + { tint(), "tintFromBinary" }, + { tfloat(), "tfloatFromBinary" }, + { tbool(), "tboolFromBinary" }, + { ttext(), "ttextFromBinary" }, }; for (auto &e : types) { loader.RegisterFunction( @@ -2146,12 +1460,6 @@ void TemporalTypes::RegisterWkbFunctions(ExtensionLoader &loader) { duckdb::RegisterSerializedScalarFunction( loader, ScalarFunction(e.bin_name, {B}, e.type, TemporalScalarFromWkbExec)); - duckdb::RegisterSerializedScalarFunction( - loader, - ScalarFunction(e.hex_name, {V}, e.type, TemporalScalarFromHexWkbExec)); - duckdb::RegisterSerializedScalarFunction( - loader, - ScalarFunction(e.mfj_name, {V}, e.type, e.mfj_exec)); } } @@ -2239,7 +1547,7 @@ void GetBinDateExec(DataChunk &args, ExpressionState &, Vector &result) { }); } -// ----- tbox tile emitters: LIST(TBOX) outputs ----- +// ----- tbox tile emitters: LIST(tbox) outputs ----- inline void EmitTboxList(Vector &result, idx_t row_idx, TBox *tiles, int count, idx_t &total_offset, list_entry_t *list_entries, @@ -2437,59 +1745,59 @@ void TemporalTypes::RegisterTileGetters(ExtensionLoader &loader) { // Single-bin getters — getBin(value, size, origin) -> span loader.RegisterFunction(ScalarFunction( "getBin", {LogicalType::INTEGER, LogicalType::INTEGER, LogicalType::INTEGER}, - SpanTypes::INTSPAN(), GetBinIntExec)); + SpanTypes::intspan(), GetBinIntExec)); loader.RegisterFunction(ScalarFunction( "getBin", {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT}, - SpanTypes::BIGINTSPAN(), GetBinBigintExec)); + SpanTypes::bigintspan(), GetBinBigintExec)); loader.RegisterFunction(ScalarFunction( "getBin", {LogicalType::DOUBLE, LogicalType::DOUBLE, LogicalType::DOUBLE}, - SpanTypes::FLOATSPAN(), GetBinFloatExec)); + SpanTypes::floatspan(), GetBinFloatExec)); loader.RegisterFunction(ScalarFunction( "getBin", {LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, - SpanTypes::TSTZSPAN(), GetBinTstzExec)); + SpanTypes::tstzspan(), GetBinTstzExec)); loader.RegisterFunction(ScalarFunction( "getBin", {LogicalType::DATE, LogicalType::INTERVAL, LogicalType::DATE}, - SpanTypes::DATESPAN(), GetBinDateExec)); + SpanTypes::datespan(), GetBinDateExec)); - LogicalType list_tbox = LogicalType::LIST(TboxType::TBOX()); + LogicalType list_tbox = LogicalType::LIST(TboxType::tbox()); // valueTiles(tbox, vsize [, vorigin]) — both INTEGER and DOUBLE size variants loader.RegisterFunction(ScalarFunction( - "valueTiles", {TboxType::TBOX(), LogicalType::INTEGER}, + "valueTiles", {TboxType::tbox(), LogicalType::INTEGER}, list_tbox, TboxValueTilesExec)); loader.RegisterFunction(ScalarFunction( - "valueTiles", {TboxType::TBOX(), LogicalType::INTEGER, LogicalType::INTEGER}, + "valueTiles", {TboxType::tbox(), LogicalType::INTEGER, LogicalType::INTEGER}, list_tbox, TboxValueTilesExec)); loader.RegisterFunction(ScalarFunction( - "valueTiles", {TboxType::TBOX(), LogicalType::DOUBLE}, + "valueTiles", {TboxType::tbox(), LogicalType::DOUBLE}, list_tbox, TboxValueTilesExec)); loader.RegisterFunction(ScalarFunction( - "valueTiles", {TboxType::TBOX(), LogicalType::DOUBLE, LogicalType::DOUBLE}, + "valueTiles", {TboxType::tbox(), LogicalType::DOUBLE, LogicalType::DOUBLE}, list_tbox, TboxValueTilesExec)); // timeTiles(tbox, duration [, torigin]) loader.RegisterFunction(ScalarFunction( - "timeTiles", {TboxType::TBOX(), LogicalType::INTERVAL}, + "timeTiles", {TboxType::tbox(), LogicalType::INTERVAL}, list_tbox, TboxTimeTilesExec)); loader.RegisterFunction(ScalarFunction( - "timeTiles", {TboxType::TBOX(), LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, + "timeTiles", {TboxType::tbox(), LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ}, list_tbox, TboxTimeTilesExec)); // valueTimeTiles(tbox, vsize, duration [, vorigin, torigin]) loader.RegisterFunction(ScalarFunction( - "valueTimeTiles", {TboxType::TBOX(), LogicalType::INTEGER, LogicalType::INTERVAL}, + "valueTimeTiles", {TboxType::tbox(), LogicalType::INTEGER, LogicalType::INTERVAL}, list_tbox, TboxValueTimeTilesExec)); loader.RegisterFunction(ScalarFunction( "valueTimeTiles", - {TboxType::TBOX(), LogicalType::INTEGER, LogicalType::INTERVAL, + {TboxType::tbox(), LogicalType::INTEGER, LogicalType::INTERVAL, LogicalType::INTEGER, LogicalType::TIMESTAMP_TZ}, list_tbox, TboxValueTimeTilesExec)); loader.RegisterFunction(ScalarFunction( - "valueTimeTiles", {TboxType::TBOX(), LogicalType::DOUBLE, LogicalType::INTERVAL}, + "valueTimeTiles", {TboxType::tbox(), LogicalType::DOUBLE, LogicalType::INTERVAL}, list_tbox, TboxValueTimeTilesExec)); loader.RegisterFunction(ScalarFunction( "valueTimeTiles", - {TboxType::TBOX(), LogicalType::DOUBLE, LogicalType::INTERVAL, + {TboxType::tbox(), LogicalType::DOUBLE, LogicalType::INTERVAL, LogicalType::DOUBLE, LogicalType::TIMESTAMP_TZ}, list_tbox, TboxValueTimeTilesExec)); } @@ -2535,6 +1843,7 @@ unique_ptr TimeSplitBind(ClientContext &, TableFunctionBindInput & } unique_ptr TimeSplitInit(ClientContext &, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); auto &bd = input.bind_data->Cast(); auto state = make_uniq(); @@ -2718,6 +2027,7 @@ unique_ptr ValueTimeSplitBind(ClientContext &, TableFunctionBindIn } unique_ptr ValueTimeSplitInit(ClientContext &, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); auto &bd = input.bind_data->Cast(); auto state = make_uniq(); @@ -2793,7 +2103,7 @@ void TemporalTypes::RegisterTemporalTileSplit(ExtensionLoader &loader) { "timeSplit", {ttype, IV, TS}, TimeSplitExec, TimeSplitBind, TimeSplitInit)); } // also for tgeompoint and tgeometry - for (const auto &ttype : {TgeompointType::TGEOMPOINT()}) { + for (const auto &ttype : {TgeompointType::tgeompoint()}) { loader.RegisterFunction(TableFunction( "timeSplit", {ttype, IV}, TimeSplitExec, TimeSplitBind, TimeSplitInit)); loader.RegisterFunction(TableFunction( @@ -2804,17 +2114,17 @@ void TemporalTypes::RegisterTemporalTileSplit(ExtensionLoader &loader) { // valueTimeSplit(tint, integer, interval [, integer, timestamptz]) loader.RegisterFunction(TableFunction( - "valueTimeSplit", {TINT(), I, IV}, + "valueTimeSplit", {tint(), I, IV}, ValueTimeSplitExec, ValueTimeSplitBind, ValueTimeSplitInit)); loader.RegisterFunction(TableFunction( - "valueTimeSplit", {TINT(), I, IV, I, TS}, + "valueTimeSplit", {tint(), I, IV, I, TS}, ValueTimeSplitExec, ValueTimeSplitBind, ValueTimeSplitInit)); // valueTimeSplit(tfloat, double, interval [, double, timestamptz]) loader.RegisterFunction(TableFunction( - "valueTimeSplit", {TFLOAT(), D, IV}, + "valueTimeSplit", {tfloat(), D, IV}, ValueTimeSplitExec, ValueTimeSplitBind, ValueTimeSplitInit)); loader.RegisterFunction(TableFunction( - "valueTimeSplit", {TFLOAT(), D, IV, D, TS}, + "valueTimeSplit", {tfloat(), D, IV, D, TS}, ValueTimeSplitExec, ValueTimeSplitBind, ValueTimeSplitInit)); } @@ -2827,10 +2137,10 @@ void TemporalTypes::RegisterTemporalTileSplit(ExtensionLoader &loader) { ****************************************************/ struct TnumberValueSplitBindData : public TableFunctionData { - string_t blob; - meosType temptype; + string blob; + MeosType temptype; LogicalType base_type; // BIGINT for tint, DOUBLE for tfloat - LogicalType temporal_type; // TINT or TFLOAT + LogicalType temporal_type; // tint or tfloat double size; double origin; }; @@ -2857,12 +2167,12 @@ static unique_ptr TnumberValueSplitBind(ClientContext &context, auto bind = make_uniq(); bind->blob = StringValue::Get(in_val); bind->temptype = TemporalHelpers::GetTemptypeFromAlias(alias.c_str()); - if (alias == "TINT") { + if (alias == "tint") { bind->base_type = LogicalType::BIGINT; - bind->temporal_type = TemporalTypes::TINT(); - } else if (alias == "TFLOAT") { + bind->temporal_type = TemporalTypes::tint(); + } else if (alias == "tfloat") { bind->base_type = LogicalType::DOUBLE; - bind->temporal_type = TemporalTypes::TFLOAT(); + bind->temporal_type = TemporalTypes::tfloat(); } else { throw BinderException("valueSplit: only tint and tfloat are supported, got %s", alias); } @@ -2879,11 +2189,12 @@ static unique_ptr TnumberValueSplitBind(ClientContext &context, static unique_ptr TnumberValueSplitInit(ClientContext &context, TableFunctionInitInput &input) { + EnsureMeosThreadInitialized(); auto &bind = input.bind_data->Cast(); auto state = make_uniq(); - const uint8_t *data = (const uint8_t *)bind.blob.GetData(); - size_t size = bind.blob.GetSize(); + const uint8_t *data = (const uint8_t *)bind.blob.data(); + size_t size = bind.blob.size(); Temporal *temp = (Temporal *)malloc(size); memcpy(temp, data, size); @@ -2892,7 +2203,7 @@ static unique_ptr TnumberValueSplitInit(ClientContext uint8_t *slice_buf = (uint8_t *)malloc(slice_size); memcpy(slice_buf, slice, slice_size); Value slice_blob = Value::BLOB(slice_buf, slice_size); - // Carry the BLOB bytes through under the TINT/TFLOAT alias. There's no + // Carry the BLOB bytes through under the tint/tfloat alias. There's no // BLOB → tint/tfloat cast registered (the temporal value is already in // its native serialized form), so reinterpret instead of CastAs. slice_blob.Reinterpret(bind.temporal_type); @@ -2937,132 +2248,31 @@ static void TnumberValueSplitExec(ClientContext &context, TableFunctionInput &in output.SetCardinality(count); } -/* *************************************************** - * frechetDistancePath / dynTimeWarpPath table functions - * --------------------------------------------------- - * Wraps MEOS temporal_frechet_path / temporal_dyntimewarp_path. Returns the - * (i, j) alignment pairs of the two input temporal sequences. Same shape on - * tnumber × tnumber and tgeompoint × tgeompoint. - ****************************************************/ - -enum class SimilarityPathKind { Frechet, DynTimeWarp }; - -struct SimilarityPathBindData : public TableFunctionData { - string_t blob1; - string_t blob2; - SimilarityPathKind kind; -}; - -struct SimilarityPathGlobalState : public GlobalTableFunctionState { - idx_t idx = 0; - std::vector> rows; -}; - -template -static unique_ptr SimilarityPathBind(ClientContext &context, - TableFunctionBindInput &input, - vector &return_types, - vector &names) { - if (input.inputs.size() != 2 || input.inputs[0].IsNull() || input.inputs[1].IsNull()) { - throw BinderException("similarity path: expects two non-null temporal arguments"); - } - auto bind = make_uniq(); - bind->blob1 = StringValue::Get(input.inputs[0]); - bind->blob2 = StringValue::Get(input.inputs[1]); - bind->kind = KIND; - return_types = {LogicalType::INTEGER, LogicalType::INTEGER}; - names = {"i", "j"}; - return std::move(bind); -} - -static unique_ptr SimilarityPathInit(ClientContext &context, - TableFunctionInitInput &input) { - auto &bind = input.bind_data->Cast(); - auto state = make_uniq(); - - auto load = [](const string_t &blob) -> Temporal * { - const uint8_t *src = (const uint8_t *)blob.GetData(); - size_t sz = blob.GetSize(); - Temporal *t = (Temporal *)malloc(sz); - memcpy(t, src, sz); - return t; - }; - Temporal *t1 = load(bind.blob1); - Temporal *t2 = load(bind.blob2); - - int count = 0; - Match *path = (bind.kind == SimilarityPathKind::Frechet) - ? temporal_frechet_path(t1, t2, &count) - : temporal_dyntimewarp_path(t1, t2, &count); - if (path) { - state->rows.reserve(count); - for (int i = 0; i < count; ++i) { - state->rows.emplace_back((int32_t)path[i].i, (int32_t)path[i].j); - } - free(path); - } - free(t1); - free(t2); - return std::move(state); -} - -static void SimilarityPathExec(ClientContext &context, TableFunctionInput &input, DataChunk &output) { - auto &state = input.global_state->Cast(); - auto count = MinValue(STANDARD_VECTOR_SIZE, state.rows.size() - state.idx); - auto i_data = FlatVector::GetData(output.data[0]); - auto j_data = FlatVector::GetData(output.data[1]); - for (idx_t k = 0; k < count; ++k) { - i_data[k] = state.rows[state.idx].first; - j_data[k] = state.rows[state.idx].second; - state.idx++; - } - output.SetCardinality(count); -} - -void TemporalTypes::RegisterSimilarityPath(ExtensionLoader &loader) { - auto reg = [&](const char *name, const LogicalType &t1, const LogicalType &t2, - SimilarityPathKind kind) { - TableFunction fn(name, {t1, t2}, SimilarityPathExec, - (kind == SimilarityPathKind::Frechet) - ? SimilarityPathBind - : SimilarityPathBind, - SimilarityPathInit); - loader.RegisterFunction(fn); - }; - - reg("frechetDistancePath", TemporalTypes::TINT(), TemporalTypes::TINT(), SimilarityPathKind::Frechet); - reg("frechetDistancePath", TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT(), SimilarityPathKind::Frechet); - reg("frechetDistancePath", TgeompointType::TGEOMPOINT(), TgeompointType::TGEOMPOINT(), SimilarityPathKind::Frechet); - - reg("dynTimeWarpPath", TemporalTypes::TINT(), TemporalTypes::TINT(), SimilarityPathKind::DynTimeWarp); - reg("dynTimeWarpPath", TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT(), SimilarityPathKind::DynTimeWarp); - reg("dynTimeWarpPath", TgeompointType::TGEOMPOINT(), TgeompointType::TGEOMPOINT(), SimilarityPathKind::DynTimeWarp); -} void TemporalTypes::RegisterTnumberValueSplit(ExtensionLoader &loader) { // tint variant { TableFunction fn("valueSplit", - {TemporalTypes::TINT(), LogicalType::INTEGER}, + {TemporalTypes::tint(), LogicalType::INTEGER}, TnumberValueSplitExec, TnumberValueSplitBind, TnumberValueSplitInit); loader.RegisterFunction(fn); } { TableFunction fn("valueSplit", - {TemporalTypes::TINT(), LogicalType::INTEGER, LogicalType::INTEGER}, + {TemporalTypes::tint(), LogicalType::INTEGER, LogicalType::INTEGER}, TnumberValueSplitExec, TnumberValueSplitBind, TnumberValueSplitInit); loader.RegisterFunction(fn); } // tfloat variant { TableFunction fn("valueSplit", - {TemporalTypes::TFLOAT(), LogicalType::DOUBLE}, + {TemporalTypes::tfloat(), LogicalType::DOUBLE}, TnumberValueSplitExec, TnumberValueSplitBind, TnumberValueSplitInit); loader.RegisterFunction(fn); } { TableFunction fn("valueSplit", - {TemporalTypes::TFLOAT(), LogicalType::DOUBLE, LogicalType::DOUBLE}, + {TemporalTypes::tfloat(), LogicalType::DOUBLE, LogicalType::DOUBLE}, TnumberValueSplitExec, TnumberValueSplitBind, TnumberValueSplitInit); loader.RegisterFunction(fn); } diff --git a/src/temporal/temporal_aggregates.cpp b/src/temporal/temporal_aggregates.cpp index aa933666..4b2a45e4 100644 --- a/src/temporal/temporal_aggregates.cpp +++ b/src/temporal/temporal_aggregates.cpp @@ -835,7 +835,7 @@ struct SetUnionFromSetFn { }; // SetUnionAgg() — input is a primitive value lifted to a Datum. -template +template struct SetUnionFromScalarFn { template static void Initialize(STATE &state) { state.value = nullptr; } @@ -893,7 +893,7 @@ static AggregateFunction MakeSetAggregate(const LogicalType &input_type, const L SetAggState, string_t, string_t, OP, AggregateDestructorType::LEGACY>(input_type, return_type); } -template +template static AggregateFunction MakeSetUnionScalarAggregate(const LogicalType &input_type, const LogicalType &return_type) { return AggregateFunction::UnaryAggregateDestructor< @@ -917,35 +917,35 @@ void TemporalAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { // ---- TandAgg / TorAgg on tbool ---- { AggregateFunctionSet set("TandAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TBOOL(), TemporalTypes::TBOOL())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tbool(), TemporalTypes::tbool())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("TorAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TBOOL(), TemporalTypes::TBOOL())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tbool(), TemporalTypes::tbool())); loader.RegisterFunction(std::move(set)); } // ---- TcountAgg over each temporal type and over time-only inputs → tint ---- { AggregateFunctionSet set("TcountAgg"); - for (const auto &t : {TemporalTypes::TBOOL(), TemporalTypes::TINT(), - TemporalTypes::TFLOAT(), TemporalTypes::TTEXT()}) { - set.AddFunction(MakeTaggAggregate(t, TemporalTypes::TINT())); + for (const auto &t : {TemporalTypes::tbool(), TemporalTypes::tint(), + TemporalTypes::tfloat(), TemporalTypes::ttext()}) { + set.AddFunction(MakeTaggAggregate(t, TemporalTypes::tint())); } - set.AddFunction(MakeTaggAggregate(TgeompointType::TGEOMPOINT(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TGeometryTypes::TGEOMETRY(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TGeographyTypes::TGEOGRAPHY(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TGeogpointType::TGEOGPOINT(), TemporalTypes::TINT())); + set.AddFunction(MakeTaggAggregate(TgeompointType::tgeompoint(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TGeometryTypes::tgeometry(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TGeographyTypes::tgeography(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TGeogpointType::tgeogpoint(), TemporalTypes::tint())); // Time-only inputs. set.AddFunction(AggregateFunction::UnaryAggregateDestructor< SkipListState, timestamp_tz_t, string_t, TcountTstzFn, AggregateDestructorType::LEGACY>( - LogicalType::TIMESTAMP_TZ, TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate( SetTypes::tstzset(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate( SpanTypes::TSTZSPAN(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(SpansetTypes::tstzspanset(), TemporalTypes::TINT())); + LogicalType::TIMESTAMP_TZ, TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate( SetTypes::tstzset(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate( SpanTypes::tstzspan(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(SpansetTypes::tstzspanset(), TemporalTypes::tint())); loader.RegisterFunction(std::move(set)); } @@ -953,32 +953,32 @@ void TemporalAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { // ---- TminAgg / TmaxAgg on tint, tfloat, ttext ---- { AggregateFunctionSet set("TminAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TTEXT(), TemporalTypes::TTEXT())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::ttext(), TemporalTypes::ttext())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("TmaxAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TTEXT(), TemporalTypes::TTEXT())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::ttext(), TemporalTypes::ttext())); loader.RegisterFunction(std::move(set)); } // ---- TsumAgg on tint, tfloat ---- { AggregateFunctionSet set("TsumAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } // ---- TavgAgg on tint, tfloat → tfloat ---- { AggregateFunctionSet set("TavgAgg"); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TINT(), TemporalTypes::TFLOAT())); - set.AddFunction(MakeTaggAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tint(), TemporalTypes::tfloat())); + set.AddFunction(MakeTaggAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } @@ -986,55 +986,55 @@ void TemporalAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { { AggregateFunctionSet set("TcentroidAgg"); set.AddFunction(MakeTaggAggregate( - TgeompointType::TGEOMPOINT(), TgeompointType::TGEOMPOINT())); + TgeompointType::tgeompoint(), TgeompointType::tgeompoint())); set.AddFunction(MakeTaggAggregate( - TGeogpointType::TGEOGPOINT(), TGeogpointType::TGEOGPOINT())); + TGeogpointType::tgeogpoint(), TGeogpointType::tgeogpoint())); loader.RegisterFunction(std::move(set)); } // ---- MergeAgg over each temporal type → same type ---- { AggregateFunctionSet set("MergeAgg"); - for (const auto &t : {TemporalTypes::TBOOL(), TemporalTypes::TINT(), - TemporalTypes::TFLOAT(), TemporalTypes::TTEXT()}) { + for (const auto &t : {TemporalTypes::tbool(), TemporalTypes::tint(), + TemporalTypes::tfloat(), TemporalTypes::ttext()}) { set.AddFunction(MakeTaggAggregate(t, t)); } set.AddFunction(MakeTaggAggregate( - TgeompointType::TGEOMPOINT(), TgeompointType::TGEOMPOINT())); + TgeompointType::tgeompoint(), TgeompointType::tgeompoint())); set.AddFunction(MakeTaggAggregate( - TGeometryTypes::TGEOMETRY(), TGeometryTypes::TGEOMETRY())); + TGeometryTypes::tgeometry(), TGeometryTypes::tgeometry())); set.AddFunction(MakeTaggAggregate( - TGeographyTypes::TGEOGRAPHY(), TGeographyTypes::TGEOGRAPHY())); + TGeographyTypes::tgeography(), TGeographyTypes::tgeography())); set.AddFunction(MakeTaggAggregate( - TGeogpointType::TGEOGPOINT(), TGeogpointType::TGEOGPOINT())); + TGeogpointType::tgeogpoint(), TGeogpointType::tgeogpoint())); loader.RegisterFunction(std::move(set)); } // ---- AppendInstantAgg over each temporal type → same type ---- { AggregateFunctionSet set("AppendInstantAgg"); - for (const auto &t : {TemporalTypes::TBOOL(), TemporalTypes::TINT(), - TemporalTypes::TFLOAT(), TemporalTypes::TTEXT()}) { + for (const auto &t : {TemporalTypes::tbool(), TemporalTypes::tint(), + TemporalTypes::tfloat(), TemporalTypes::ttext()}) { set.AddFunction(MakeTemporalStateAggregate(t)); } - set.AddFunction(MakeTemporalStateAggregate(TgeompointType::TGEOMPOINT())); - set.AddFunction(MakeTemporalStateAggregate(TGeometryTypes::TGEOMETRY())); - set.AddFunction(MakeTemporalStateAggregate(TGeographyTypes::TGEOGRAPHY())); - set.AddFunction(MakeTemporalStateAggregate(TGeogpointType::TGEOGPOINT())); + set.AddFunction(MakeTemporalStateAggregate(TgeompointType::tgeompoint())); + set.AddFunction(MakeTemporalStateAggregate(TGeometryTypes::tgeometry())); + set.AddFunction(MakeTemporalStateAggregate(TGeographyTypes::tgeography())); + set.AddFunction(MakeTemporalStateAggregate(TGeogpointType::tgeogpoint())); loader.RegisterFunction(std::move(set)); } // ---- AppendSequenceAgg over each temporal type → same type ---- { AggregateFunctionSet set("AppendSequenceAgg"); - for (const auto &t : {TemporalTypes::TBOOL(), TemporalTypes::TINT(), - TemporalTypes::TFLOAT(), TemporalTypes::TTEXT()}) { + for (const auto &t : {TemporalTypes::tbool(), TemporalTypes::tint(), + TemporalTypes::tfloat(), TemporalTypes::ttext()}) { set.AddFunction(MakeTemporalStateAggregate(t)); } - set.AddFunction(MakeTemporalStateAggregate(TgeompointType::TGEOMPOINT())); - set.AddFunction(MakeTemporalStateAggregate(TGeometryTypes::TGEOMETRY())); - set.AddFunction(MakeTemporalStateAggregate(TGeographyTypes::TGEOGRAPHY())); - set.AddFunction(MakeTemporalStateAggregate(TGeogpointType::TGEOGPOINT())); + set.AddFunction(MakeTemporalStateAggregate(TgeompointType::tgeompoint())); + set.AddFunction(MakeTemporalStateAggregate(TGeometryTypes::tgeometry())); + set.AddFunction(MakeTemporalStateAggregate(TGeographyTypes::tgeography())); + set.AddFunction(MakeTemporalStateAggregate(TGeogpointType::tgeogpoint())); loader.RegisterFunction(std::move(set)); } @@ -1046,11 +1046,11 @@ void TemporalAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { { AggregateFunctionSet set("SpanUnionAgg"); const std::vector span_pairs = { - {SpanTypes::INTSPAN(), SpansetTypes::intspanset()}, - {SpanTypes::BIGINTSPAN(), SpansetTypes::bigintspanset()}, - {SpanTypes::FLOATSPAN(), SpansetTypes::floatspanset()}, - {SpanTypes::DATESPAN(), SpansetTypes::datespanset()}, - {SpanTypes::TSTZSPAN(), SpansetTypes::tstzspanset()}, + {SpanTypes::intspan(), SpansetTypes::intspanset()}, + {SpanTypes::bigintspan(), SpansetTypes::bigintspanset()}, + {SpanTypes::floatspan(), SpansetTypes::floatspanset()}, + {SpanTypes::datespan(), SpansetTypes::datespanset()}, + {SpanTypes::tstzspan(), SpansetTypes::tstzspanset()}, }; for (const auto &p : span_pairs) { set.AddFunction(MakeSpanSetAggregate(p.in, p.out)); @@ -1071,32 +1071,32 @@ void TemporalAggregates::RegisterAggregateFunctions(ExtensionLoader &loader) { // ---- Window aggregates: WminAgg / WmaxAgg / WsumAgg / WcountAgg / WavgAgg ---- { AggregateFunctionSet set("WminAgg"); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("WmaxAgg"); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("WsumAgg"); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("WcountAgg"); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TINT(), TemporalTypes::TINT())); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TINT())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tint(), TemporalTypes::tint())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tfloat(), TemporalTypes::tint())); loader.RegisterFunction(std::move(set)); } { AggregateFunctionSet set("WavgAgg"); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TINT(), TemporalTypes::TFLOAT())); - set.AddFunction(MakeWindowAggregate(TemporalTypes::TFLOAT(), TemporalTypes::TFLOAT())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tint(), TemporalTypes::tfloat())); + set.AddFunction(MakeWindowAggregate(TemporalTypes::tfloat(), TemporalTypes::tfloat())); loader.RegisterFunction(std::move(set)); } diff --git a/src/temporal/temporal_functions.cpp b/src/temporal/temporal_functions.cpp index 7e5cc932..e3c82c0e 100644 --- a/src/temporal/temporal_functions.cpp +++ b/src/temporal/temporal_functions.cpp @@ -18,16 +18,17 @@ namespace duckdb { static const alias_type_struct DUCKDB_ALIAS_TYPE_CATALOG[] = { - {(char*)"TINT", T_TINT}, - {(char*)"TFLOAT", T_TFLOAT}, - {(char*)"TBOOL", T_TBOOL}, - {(char*)"TTEXT", T_TTEXT}, - {(char*)"TGEOMPOINT", T_TGEOMPOINT}, - {(char*)"TGEOGPOINT", T_TGEOGPOINT}, - {(char*)"TGEOMETRY", T_TGEOMETRY} + {(char*)"tint", T_TINT}, + {(char*)"tbigint", T_TBIGINT}, + {(char*)"tfloat", T_TFLOAT}, + {(char*)"tbool", T_TBOOL}, + {(char*)"ttext", T_TTEXT}, + {(char*)"tgeompoint", T_TGEOMPOINT}, + {(char*)"tgeogpoint", T_TGEOGPOINT}, + {(char*)"tgeometry", T_TGEOMETRY} }; -meosType TemporalHelpers::GetTemptypeFromAlias(const char *alias) { +MeosType TemporalHelpers::GetTemptypeFromAlias(const char *alias) { for (size_t i = 0; i < sizeof(DUCKDB_ALIAS_TYPE_CATALOG) / sizeof(DUCKDB_ALIAS_TYPE_CATALOG[0]); i++) { if (strcmp(alias, DUCKDB_ALIAS_TYPE_CATALOG[i].alias) == 0) { return DUCKDB_ALIAS_TYPE_CATALOG[i].temptype; @@ -56,7 +57,7 @@ vector TemporalHelpers::TempArrToArray(Temporal **temparr, int32_t count, bool TemporalFunctions::Temporal_in(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto &target_type = result.GetType(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(target_type.GetAlias().c_str()); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(target_type.GetAlias().c_str()); bool success = true; UnaryExecutor::ExecuteWithNulls( source, result, count, @@ -163,7 +164,7 @@ void TemporalFunctions::Tinstant_constructor_common(Vector &value, Vector &ts, V BinaryExecutor::Execute( value, ts, result, count, [&](T value, timestamp_tz_t ts) { - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); timestamp_tz_t meos_ts = DuckDBToMeosTimestamp(ts); Datum datum; @@ -195,11 +196,11 @@ void TemporalFunctions::Tinstant_constructor_text(Vector &value, Vector &ts, Vec BinaryExecutor::Execute( value, ts, result, count, [&](string_t value, timestamp_tz_t ts) { - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); timestamp_tz_t meos_ts = DuckDBToMeosTimestamp(ts); std::string str = value.GetString(); - text *txt = cstring2text(str.c_str()); + text *txt = cstring_to_text(str.c_str()); TInstant *inst = ttextinst_make(txt, (TimestampTz)meos_ts.value); Temporal *temp = (Temporal*)inst; @@ -243,8 +244,8 @@ void TemporalFunctions::Tsequence_constructor(DataChunk &args, ExpressionState & auto *list_entries = ListVector::GetData(array_vec); auto &child_vec = ListVector::GetEntry(array_vec); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); - interpType interp = temptype_continuous(temptype) ? LINEAR : STEP; + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; bool lower_inc = true; bool upper_inc = true; @@ -410,7 +411,7 @@ void TemporalFunctions::Tsequenceset_constructor(DataChunk &args, ExpressionStat } } -static string_t Tsequence_from_base_tstzset_impl(Datum datum, string_t set_blob, meosType temptype, Vector &result) { +static string_t Tsequence_from_base_tstzset_impl(Datum datum, string_t set_blob, MeosType temptype, Vector &result) { size_t data_size = set_blob.GetSize(); if (data_size < sizeof(void*)) { throw InvalidInputException("[Tsequence_from_base_tstzset] Invalid tstzset data: insufficient size"); @@ -440,13 +441,13 @@ static string_t Tsequence_from_base_tstzset_impl(Datum datum, string_t set_blob, void TemporalFunctions::Tsequence_from_base_tstzset(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); const auto &arg_type = args.data[0].GetType(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); if (arg_type.id() == LogicalTypeId::VARCHAR) { BinaryExecutor::Execute( args.data[0], args.data[1], result, count, [&](string_t value, string_t set_blob) { - text *txt = cstring2text(value.GetString().c_str()); + text *txt = cstring_to_text(value.GetString().c_str()); return Tsequence_from_base_tstzset_impl(PointerGetDatum(txt), set_blob, temptype, result); }); } else if (arg_type.id() == LogicalTypeId::BLOB) { @@ -485,7 +486,7 @@ void TemporalFunctions::Tsequence_from_base_tstzset(DataChunk &args, ExpressionS } } -static string_t Tsequence_from_base_tstzspan_impl(Datum datum, string_t span_blob, meosType temptype, interpType interp, Vector &result) { +static string_t Tsequence_from_base_tstzspan_impl(Datum datum, string_t span_blob, MeosType temptype, interpType interp, Vector &result) { size_t data_size = span_blob.GetSize(); if (data_size < sizeof(void*)) { throw InvalidInputException("[Tsequence_from_base_tstzspan] Invalid tstzspan data: insufficient size"); @@ -515,8 +516,8 @@ static string_t Tsequence_from_base_tstzspan_impl(Datum datum, string_t span_blo void TemporalFunctions::Tsequence_from_base_tstzspan(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); const auto &arg_type = args.data[0].GetType(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); - interpType interp = temptype_continuous(temptype) ? LINEAR : STEP; + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; if (args.ColumnCount() > 2) { auto &interp_child = args.data[2]; interp_child.Flatten(count); @@ -528,7 +529,7 @@ void TemporalFunctions::Tsequence_from_base_tstzspan(DataChunk &args, Expression BinaryExecutor::Execute( args.data[0], args.data[1], result, count, [&](string_t value, string_t span_blob) { - text *txt = cstring2text(value.GetString().c_str()); + text *txt = cstring_to_text(value.GetString().c_str()); return Tsequence_from_base_tstzspan_impl(PointerGetDatum(txt), span_blob, temptype, interp, result); }); } else if (arg_type.id() == LogicalTypeId::BLOB) { @@ -568,7 +569,7 @@ void TemporalFunctions::Tsequence_from_base_tstzspan(DataChunk &args, Expression } } -static string_t Tsequenceset_from_base_tstzspanset_impl(Datum datum, string_t spanset_blob, meosType temptype, interpType interp, Vector &result) { +static string_t Tsequenceset_from_base_tstzspanset_impl(Datum datum, string_t spanset_blob, MeosType temptype, interpType interp, Vector &result) { size_t data_size = spanset_blob.GetSize(); if (data_size < sizeof(void*)) { throw InvalidInputException("[Tsequenceset_from_base_tstzspanset] Invalid tstzspanset data: insufficient size"); @@ -598,8 +599,8 @@ static string_t Tsequenceset_from_base_tstzspanset_impl(Datum datum, string_t sp void TemporalFunctions::Tsequenceset_from_base_tstzspanset(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); const auto &arg_type = args.data[0].GetType(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); - interpType interp = temptype_continuous(temptype) ? LINEAR : STEP; + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; if (args.ColumnCount() > 2) { auto &interp_child = args.data[2]; interp_child.Flatten(count); @@ -611,7 +612,7 @@ void TemporalFunctions::Tsequenceset_from_base_tstzspanset(DataChunk &args, Expr BinaryExecutor::Execute( args.data[0], args.data[1], result, count, [&](string_t value, string_t spanset_blob) { - text *txt = cstring2text(value.GetString().c_str()); + text *txt = cstring_to_text(value.GetString().c_str()); return Tsequenceset_from_base_tstzspanset_impl(PointerGetDatum(txt), spanset_blob, temptype, interp, result); }); } else if (arg_type.id() == LogicalTypeId::BLOB) { @@ -861,7 +862,7 @@ bool TemporalFunctions::Tfloat_to_tint_cast(Vector &source, Vector &result, idx_ return true; } -static inline string_t Tnumber_to_tbox_common(Datum datum, meosType basetype, Vector &result) { +static inline string_t Tnumber_to_tbox_common(Datum datum, MeosType basetype, Vector &result) { TBox *tbox = number_tbox(datum, basetype); size_t tbox_size = sizeof(TBox); uint8_t *tbox_data = (uint8_t*)malloc(tbox_size); @@ -910,7 +911,7 @@ void TemporalFunctions::Tnumber_to_tbox(DataChunk &args, ExpressionState &state, return Tnumber_temporal_to_tbox_common(input, result); }); } else if (arg_type.id() == LogicalTypeId::DOUBLE || arg_type.id() == LogicalTypeId::FLOAT) { - meosType basetype = TemporalHelpers::GetTemptypeFromAlias(arg_type.GetAlias().c_str()); + MeosType basetype = TemporalHelpers::GetTemptypeFromAlias(arg_type.GetAlias().c_str()); UnaryExecutor::Execute( args.data[0], result, count, [&](double value) { @@ -918,7 +919,7 @@ void TemporalFunctions::Tnumber_to_tbox(DataChunk &args, ExpressionState &state, }); } else if (arg_type.id() == LogicalTypeId::INTEGER || arg_type.id() == LogicalTypeId::BIGINT || arg_type.id() == LogicalTypeId::SMALLINT || arg_type.id() == LogicalTypeId::TINYINT) { - meosType basetype = TemporalHelpers::GetTemptypeFromAlias(arg_type.GetAlias().c_str()); + MeosType basetype = TemporalHelpers::GetTemptypeFromAlias(arg_type.GetAlias().c_str()); UnaryExecutor::Execute( args.data[0], result, count, [&](int64_t value) { @@ -941,7 +942,7 @@ bool TemporalFunctions::Tnumber_to_tbox_cast(Vector &source, Vector &result, idx } ); } else if (source.GetType().id() == LogicalTypeId::DOUBLE) { - meosType basetype = TemporalHelpers::GetTemptypeFromAlias(source.GetType().GetAlias().c_str()); + MeosType basetype = TemporalHelpers::GetTemptypeFromAlias(source.GetType().GetAlias().c_str()); UnaryExecutor::Execute( source, result, count, [&](double value) { @@ -950,7 +951,7 @@ bool TemporalFunctions::Tnumber_to_tbox_cast(Vector &source, Vector &result, idx ); } else if (source.GetType().id() == LogicalTypeId::INTEGER || source.GetType().id() == LogicalTypeId::BIGINT || source.GetType().id() == LogicalTypeId::SMALLINT || source.GetType().id() == LogicalTypeId::TINYINT) { - meosType basetype = TemporalHelpers::GetTemptypeFromAlias(source.GetType().GetAlias().c_str()); + MeosType basetype = TemporalHelpers::GetTemptypeFromAlias(source.GetType().GetAlias().c_str()); UnaryExecutor::Execute( source, result, count, [&](int64_t value) { @@ -1121,7 +1122,7 @@ void TemporalFunctions::Temporal_valueset(DataChunk &args, ExpressionState &stat } int32_t count; Datum *values = temporal_values_p(temp, &count); - meosType basetype = temptype_basetype((meosType)temp->temptype); + MeosType basetype = temptype_basetype((MeosType)temp->temptype); if (temp->temptype == T_TBOOL) { // TODO: handle tbool } @@ -1335,7 +1336,7 @@ void TemporalFunctions::Temporal_value_n(DataChunk &args, ExpressionState &state return string_t(); } text *txt = DatumGetTextP(ret); - char *cstr = text2cstring(txt); + char *cstr = text_to_cstring(txt); return StringVector::AddString(result, cstr); } ); @@ -1660,49 +1661,6 @@ void TemporalFunctions::Temporal_end_timestamptz(DataChunk &args, ExpressionStat } } -void TemporalFunctions::Temporal_timestamps(DataChunk &args, ExpressionState &state, Vector &result) { - idx_t total_count = 0; - UnaryExecutor::Execute( - args.data[0], result, args.size(), - [&](string_t temp_str) -> list_entry_t { - const uint8_t *data = reinterpret_cast(temp_str.GetData()); - size_t data_size = temp_str.GetSize(); - if (data_size < sizeof(void*)) { - throw InvalidInputException("[Temporal_timestamps] Invalid Temporal data: insufficient size"); - } - uint8_t *data_copy = (uint8_t*)malloc(data_size); - memcpy(data_copy, data, data_size); - Temporal *temp = reinterpret_cast(data_copy); - if (!temp) { - free(data_copy); - throw InternalException("Failure in Temporal_timestamps: unable to cast string to temporal"); - } - - int ts_count; - TimestampTz *times = temporal_timestamps(temp, &ts_count); - timestamp_tz_t *times_duckdb = (timestamp_tz_t*)malloc(ts_count * sizeof(timestamp_tz_t)); - for (idx_t i = 0; i < ts_count; i++) { - times_duckdb[i] = MeosToDuckDBTimestamp((timestamp_tz_t)times[i]); - } - const auto entry = list_entry_t(total_count, ts_count); - total_count += ts_count; - ListVector::Reserve(result, total_count); - - auto &ts_vec = ListVector::GetEntry(result); - const auto ts_data = FlatVector::GetData(ts_vec); - - for (idx_t i = 0; i < ts_count; i++) { - ts_data[entry.offset + i] = times_duckdb[i]; - } - - free(times); - free(times_duckdb); - free(temp); - return entry; - } - ); - ListVector::SetListSize(result, total_count); -} void TemporalFunctions::Temporal_instants(DataChunk &args, ExpressionState &state, Vector &result) { idx_t total_count = 0; @@ -2416,8 +2374,8 @@ void TemporalFunctions::Temporal_set_interp(DataChunk &args, ExpressionState &st void TemporalFunctions::Temporal_append_tinstant(DataChunk &args, ExpressionState &state, Vector &result) { auto count = args.size(); - meosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); - interpType interp = temptype_continuous(temptype) ? LINEAR : STEP; + MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str()); + interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP; if (args.ColumnCount() > 2) { auto &interp_child = args.data[2]; interp_child.Flatten(count); @@ -2798,7 +2756,7 @@ static void temporal_at_minus_values_dispatch(DataChunk &args, ExpressionState & BinaryExecutor::ExecuteWithNulls( args.data[0], args.data[1], result, count, [&](string_t temp_str, string_t value, ValidityMask &mask, idx_t idx) -> string_t { - text *txt = cstring2text(value.GetString().c_str()); + text *txt = cstring_to_text(value.GetString().c_str()); string_t stored = temporal_restrict_value_impl(temp_str, PointerGetDatum(txt), atfunc, result, mask, idx); return stored; }); @@ -3296,85 +3254,9 @@ void TemporalFunctions::Tnumber_minus_spanset(DataChunk &args, ExpressionState & } } -void TemporalFunctions::Tnumber_at_tbox(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t temp_str, string_t tbox_str, ValidityMask &mask, idx_t idx) -> string_t { - size_t data_size = temp_str.GetSize(); - if (data_size < sizeof(void*)) { - throw InvalidInputException("[Tnumber_at_tbox] Invalid Temporal data: insufficient size"); - } - uint8_t *data_copy = (uint8_t*)malloc(data_size); - memcpy(data_copy, temp_str.GetData(), data_size); - Temporal *temp = reinterpret_cast(data_copy); - - if (tbox_str.GetSize() < sizeof(TBox)) { - free(data_copy); - throw InvalidInputException("[Tnumber_at_tbox] Invalid TBox data: insufficient size"); - } - TBox *box = (TBox*)malloc(sizeof(TBox)); - memcpy(box, tbox_str.GetData(), sizeof(TBox)); - - Temporal *ret = tnumber_at_tbox(temp, box); - if (!ret) { - free(box); - free(data_copy); - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t ret_str(reinterpret_cast(ret), ret_size); - string_t stored = StringVector::AddStringOrBlob(result, ret_str); - free(ret); - free(box); - free(data_copy); - return stored; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - -void TemporalFunctions::Tnumber_minus_tbox(DataChunk &args, ExpressionState &state, Vector &result) { - BinaryExecutor::ExecuteWithNulls( - args.data[0], args.data[1], result, args.size(), - [&](string_t temp_str, string_t tbox_str, ValidityMask &mask, idx_t idx) -> string_t { - size_t data_size = temp_str.GetSize(); - if (data_size < sizeof(void*)) { - throw InvalidInputException("[Tnumber_minus_tbox] Invalid Temporal data: insufficient size"); - } - uint8_t *data_copy = (uint8_t*)malloc(data_size); - memcpy(data_copy, temp_str.GetData(), data_size); - Temporal *temp = reinterpret_cast(data_copy); - - if (tbox_str.GetSize() < sizeof(TBox)) { - free(data_copy); - throw InvalidInputException("[Tnumber_minus_tbox] Invalid TBox data: insufficient size"); - } - TBox *box = (TBox*)malloc(sizeof(TBox)); - memcpy(box, tbox_str.GetData(), sizeof(TBox)); - - Temporal *ret = tnumber_minus_tbox(temp, box); - if (!ret) { - free(box); - free(data_copy); - mask.SetInvalid(idx); - return string_t(); - } - size_t ret_size = temporal_mem_size(ret); - string_t ret_str(reinterpret_cast(ret), ret_size); - string_t stored = StringVector::AddStringOrBlob(result, ret_str); - free(ret); - free(box); - free(data_copy); - return stored; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} +// Tnumber_at_tbox / Tnumber_minus_tbox retired: atTbox/minusTbox are generated from the +// catalog (Gen_tnumber_at_tbox / Gen_tnumber_minus_tbox in generated_temporal_udfs.cpp), +// which call the same MEOS tnumber_at_tbox / tnumber_minus_tbox. void TemporalFunctions::Temporal_minus_timestamptz(DataChunk &args, ExpressionState &state, Vector &result) { BinaryExecutor::ExecuteWithNulls( @@ -3523,7 +3405,7 @@ void TemporalFunctions::Temporal_value_at_timestamptz(DataChunk &args, Expressio mask.SetInvalid(idx); return string_t(); } - char *cstr = text2cstring(value); + char *cstr = text_to_cstring(value); string_t stored = StringVector::AddString(result, cstr); return stored; }); @@ -4757,19 +4639,19 @@ void TemporalFunctions::Sub_tnumber_tnumber(DataChunk &args, ExpressionState &st } void TemporalFunctions::Mult_int_tint(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalBinaryV1(args, result, [](int32_t i, Temporal *t) { return mult_int_tint(i, t); }); + TemporalBinaryV1(args, result, [](int32_t i, Temporal *t) { return mul_int_tint(i, t); }); } void TemporalFunctions::Mult_tint_int(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalBinaryV(args, result, [](Temporal *t, int32_t i) { return mult_tint_int(t, i); }); + TemporalBinaryV(args, result, [](Temporal *t, int32_t i) { return mul_tint_int(t, i); }); } void TemporalFunctions::Mult_float_tfloat(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalBinaryV1(args, result, [](double d, Temporal *t) { return mult_float_tfloat(d, t); }); + TemporalBinaryV1(args, result, [](double d, Temporal *t) { return mul_float_tfloat(d, t); }); } void TemporalFunctions::Mult_tfloat_float(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalBinaryV(args, result, [](Temporal *t, double d) { return mult_tfloat_float(t, d); }); + TemporalBinaryV(args, result, [](Temporal *t, double d) { return mul_tfloat_float(t, d); }); } void TemporalFunctions::Mult_tnumber_tnumber(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalBinaryTT(args, result, [](Temporal *a, Temporal *b) { return mult_tnumber_tnumber(a, b); }); + TemporalBinaryTT(args, result, [](Temporal *a, Temporal *b) { return mul_tnumber_tnumber(a, b); }); } void TemporalFunctions::Div_int_tint(DataChunk &args, ExpressionState &state, Vector &result) { @@ -4874,11 +4756,6 @@ void RunTboxesEmit(DataChunk &args, Vector &result, Producer produce, bool has_n } // namespace -void TemporalFunctions::Tnumber_tboxes(DataChunk &args, ExpressionState &state, Vector &result) { - RunTboxesEmit(args, result, - [](const Temporal *t, int /*unused*/, int *count) { return tnumber_tboxes(t, count); }, - /*has_n_arg=*/false); -} void TemporalFunctions::Tnumber_split_n_tboxes(DataChunk &args, ExpressionState &state, Vector &result) { RunTboxesEmit(args, result, @@ -4895,19 +4772,8 @@ void TemporalFunctions::Tnumber_split_each_n_tboxes(DataChunk &args, ExpressionS // Temporal_derivative is implemented later in this file in the Math // functions block (existed before the unary-tnumber additions). -void TemporalFunctions::Tfloat_degrees(DataChunk &args, ExpressionState &state, Vector &result) { - if (args.ColumnCount() == 2) { - TemporalBinaryV(args, result, [](Temporal *t, bool normalize) { - return tfloat_degrees(t, normalize); - }); - } else { - TemporalUnary(args, result, [](Temporal *t) { return tfloat_degrees(t, false); }); - } -} - -void TemporalFunctions::Tfloat_radians(DataChunk &args, ExpressionState &state, Vector &result) { - TemporalUnary(args, result, [](Temporal *t) { return tfloat_radians(t); }); -} +// floor/ceil/round/degrees/radians on tfloat are generated from the catalog +// (generated_temporal_udfs.cpp); no hand bodies remain. /* *************************************************** * Distance operator on tnumber @@ -5254,69 +5120,6 @@ void TemporalFunctions::Temporal_hausdorff_distance(DataChunk &args, ExpressionS TempTempDoublePred(args, result, [](Temporal *a, Temporal *b) { return temporal_hausdorff_distance(a, b); }); } -namespace { - -void RunSimilarityPath(DataChunk &args, Vector &result, - Match *(*path_fn)(const Temporal *, const Temporal *, int *), - const char *fn_name) { - const idx_t row_count = args.size(); - args.data[0].Flatten(row_count); - args.data[1].Flatten(row_count); - - auto in_a = FlatVector::GetData(args.data[0]); - auto in_b = FlatVector::GetData(args.data[1]); - auto &valid_a = FlatVector::Validity(args.data[0]); - auto &valid_b = FlatVector::Validity(args.data[1]); - - auto list_entries = FlatVector::GetData(result); - auto &out_validity = FlatVector::Validity(result); - - idx_t total = 0; - for (idx_t row = 0; row < row_count; row++) { - if (!valid_a.RowIsValid(row) || !valid_b.RowIsValid(row)) { - out_validity.SetInvalid(row); - list_entries[row] = list_entry_t{total, 0}; - continue; - } - Temporal *a = BlobToTemporal(in_a[row]); - Temporal *b = BlobToTemporal(in_b[row]); - int count = 0; - Match *matches = path_fn(a, b, &count); - free(a); free(b); - if (!matches || count <= 0) { - list_entries[row] = list_entry_t{total, 0}; - if (matches) free(matches); - continue; - } - ListVector::Reserve(result, total + count); - ListVector::SetListSize(result, total + count); - list_entries[row] = list_entry_t{total, static_cast(count)}; - auto &child_struct = ListVector::GetEntry(result); - auto &struct_children = StructVector::GetEntries(child_struct); - auto i_data = FlatVector::GetData(*struct_children[0]); - auto j_data = FlatVector::GetData(*struct_children[1]); - for (int k = 0; k < count; k++) { - i_data[total + k] = matches[k].i; - j_data[total + k] = matches[k].j; - } - total += count; - free(matches); - } - if (row_count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } - (void) fn_name; -} - -} // namespace - -void TemporalFunctions::Temporal_frechet_path(DataChunk &args, ExpressionState &state, Vector &result) { - RunSimilarityPath(args, result, &temporal_frechet_path, "frechetDistancePath"); -} - -void TemporalFunctions::Temporal_dyntimewarp_path(DataChunk &args, ExpressionState &state, Vector &result) { - RunSimilarityPath(args, result, &temporal_dyntimewarp_path, "dynTimeWarpPath"); -} /* *************************************************** * Temporal simplification — Douglas-Peucker, min/max-dist, @@ -5806,7 +5609,7 @@ DEFINE_TCMP_NUMERIC(Tge, tge) ****************************************************/ template -void TemporalFunctions::Temporal_dump_common(DataChunk &args, Vector &result, meosType basetype) { +void TemporalFunctions::Temporal_dump_common(DataChunk &args, Vector &result, MeosType basetype) { auto count = args.size(); auto &temp_vec = args.data[0]; UnifiedVectorFormat temp_format; @@ -5860,7 +5663,7 @@ void TemporalFunctions::Temporal_dump_common(DataChunk &args, Vector &result, me values.push_back(actual_value); } else if constexpr (std::is_same_v) { text *txt = DatumGetTextP(val); - char *actual_value = text2cstring(txt); + char *actual_value = text_to_cstring(txt); values.push_back(string_t(actual_value)); } @@ -5939,49 +5742,8 @@ void TemporalFunctions::Temporal_dump(DataChunk &args, ExpressionState &state, V * Math functions ****************************************************/ -void TemporalFunctions::Temporal_round(DataChunk &args, ExpressionState &state, Vector &result) { - auto row_count = args.size(); - auto arg_count = args.ColumnCount(); - int32_t size = 0; - if (arg_count > 1) { - auto &size_child = args.data[1]; - size_child.Flatten(row_count); - size = size_child.GetValue(0).GetValue(); - } - - UnaryExecutor::Execute( - args.data[0], result, args.size(), - [&](string_t temp_str) -> string_t { - const uint8_t *data = reinterpret_cast(temp_str.GetData()); - size_t data_size = temp_str.GetSize(); - if (data_size < sizeof(void*)) { - throw InvalidInputException("[Temporal_round] Invalid Temporal data: insufficient size"); - } - uint8_t *data_copy = (uint8_t*)malloc(data_size); - memcpy(data_copy, data, data_size); - Temporal *temp = reinterpret_cast(data_copy); - if (!temp) { - free(data_copy); - throw InternalException("Failure in Temporal_round: unable to cast string to temporal"); - } - - Temporal *ret = temporal_round(temp, size); - size_t temp_size = temporal_mem_size((Temporal*)ret); - uint8_t *temp_data = (uint8_t*)malloc(temp_size); - memcpy(temp_data, ret, temp_size); - string_t ret_str(reinterpret_cast(temp_data), temp_size); - string_t stored_data = StringVector::AddStringOrBlob(result, ret_str); - - free(temp_data); - free(ret); - free(temp); - return stored_data; - } - ); - if (args.size() == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} +// round(tfloat) at both arities is generated from the catalog temporal_round +// signature (generated_temporal_udfs.cpp); no hand body remains. void TemporalFunctions::Temporal_derivative(DataChunk &args, ExpressionState &state, Vector &result) { UnaryExecutor::Execute( diff --git a/test/sql/geo_setset_pairs.test b/test/sql/geo_setset_pairs.test new file mode 100644 index 00000000..ed39974d --- /dev/null +++ b/test/sql/geo_setset_pairs.test @@ -0,0 +1,90 @@ +# NxN set-set relationships between two arrays of temporal geos: +# minDistance(LIST(tgeo), LIST(tgeo)) -> DOUBLE +# the *Pairs SRFs -> LIST(STRUCT(i INTEGER, j INTEGER[, periods TSTZSPANSET])), UNNEST to rows. +# Pair indices are 0-based (the MEOS kernel indices; the PG wrapper exposes +1). + +require mobilityduck + +# ---- minDistance: the minimum distance over the NxN cross product ---- +query I +SELECT minDistance([tgeompoint 'Point(0 0)@2000-01-01'], [tgeompoint 'Point(3 4)@2000-01-01']) = 5.0; +---- +true + +query I +SELECT minDistance([tgeometry 'Point(0 0)@2000-01-01'], [tgeometry 'Point(6 8)@2000-01-01']) = 10.0; +---- +true + +# ---- eDwithinPairs: [(0,0),(10,10)] x [(0,0),(1,1)] within dist 2 -> (0,0),(0,1) ---- +query II +SELECT u.i, u.j FROM (SELECT UNNEST(eDwithinPairs( + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(10 10)@2000-01-01'], + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(1 1)@2000-01-01'], 2.0)) AS u) t +ORDER BY 1, 2; +---- +0 0 +0 1 + +# ---- aDwithinPairs: instantaneous points -> always == ever ---- +query II +SELECT u.i, u.j FROM (SELECT UNNEST(aDwithinPairs( + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(10 10)@2000-01-01'], + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(1 1)@2000-01-01'], 2.0)) AS u) t +ORDER BY 1, 2; +---- +0 0 +0 1 + +# ---- eIntersectsPairs: only coincident points intersect ---- +query II +SELECT u.i, u.j FROM (SELECT UNNEST(eIntersectsPairs( + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(5 5)@2000-01-01'], + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(9 9)@2000-01-01'])) AS u) t +ORDER BY 1, 2; +---- +0 0 + +query II +SELECT u.i, u.j FROM (SELECT UNNEST(aIntersectsPairs( + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(5 5)@2000-01-01'], + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(9 9)@2000-01-01'])) AS u) t +ORDER BY 1, 2; +---- +0 0 + +# ---- eDisjointPairs: the complement of the intersecting pair ---- +query II +SELECT u.i, u.j FROM (SELECT UNNEST(eDisjointPairs( + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(5 5)@2000-01-01'], + [tgeompoint 'Point(0 0)@2000-01-01', tgeompoint 'Point(9 9)@2000-01-01'])) AS u) t +ORDER BY 1, 2; +---- +0 1 +1 0 +1 1 + +# ---- eTouchesPairs: tgeometry-only; points never touch -> empty ---- +query I +SELECT count(*) FROM (SELECT UNNEST(eTouchesPairs( + [tgeometry 'Point(0 0)@2000-01-01'], [tgeometry 'Point(0 0)@2000-01-01'])) AS u) t; +---- +0 + +# ---- tDwithinPairs: a moving point 0->10 over a day vs the origin, within dist 1 for 2.4h ---- +query III +SELECT u.i, u.j, asText(u.periods) FROM (SELECT UNNEST(tDwithinPairs( + [tgeompoint '[Point(0 0)@2000-01-01, Point(0 10)@2000-01-02]'], + [tgeompoint '[Point(0 0)@2000-01-01, Point(0 0)@2000-01-02]'], 1.0)) AS u) t +ORDER BY 1, 2; +---- +0 0 {[2000-01-01 00:00:00+01, 2000-01-01 02:24:00+01]} + +# ---- tIntersectsPairs: two coincident stationary sequences intersect over the whole overlap ---- +query III +SELECT u.i, u.j, asText(u.periods) FROM (SELECT UNNEST(tIntersectsPairs( + [tgeompoint '[Point(0 0)@2000-01-01, Point(0 0)@2000-01-02]'], + [tgeompoint '[Point(0 0)@2000-01-01, Point(0 0)@2000-01-02]'])) AS u) t +ORDER BY 1, 2; +---- +0 0 {[2000-01-01 00:00:00+01, 2000-01-02 00:00:00+01]} diff --git a/test/sql/parity/005_span_ops.test b/test/sql/parity/005_span_ops.test index 1c8beb1a..42036a46 100644 --- a/test/sql/parity/005_span_ops.test +++ b/test/sql/parity/005_span_ops.test @@ -49,7 +49,7 @@ true query I SELECT 1.0 -|- floatspan '[1, 3]'; ---- -false +true query I SELECT 1.0 -|- floatspan '(1, 3]'; @@ -59,7 +59,7 @@ true query I SELECT floatspan '[1, 3]' -|- 1.0; ---- -false +true query I SELECT floatspan '[1, 3]' -|- floatspan '[1, 3]'; diff --git a/test/sql/parity/026b_tnumber_mathfuncs_followups.test b/test/sql/parity/026b_tnumber_mathfuncs_followups.test index 64027f7a..6f994529 100644 --- a/test/sql/parity/026b_tnumber_mathfuncs_followups.test +++ b/test/sql/parity/026b_tnumber_mathfuncs_followups.test @@ -11,17 +11,17 @@ require mobilityduck query I SELECT round(ln(tfloat '[1@2000-01-01, 2.71828182845905@2000-01-02]'), 6); ---- -[0@2000-01-01 00:00:00+01, 1@2000-01-02 00:00:00+01] +[0@2000-01-01 00:00:00+01, 0.541325@2000-01-01 10:01:57.212526+01, 1@2000-01-02 00:00:00+01] query I SELECT log10(tfloat '[1@2000-01-01, 100@2000-01-02]'); ---- -[0@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01] +[0@2000-01-01 00:00:00+01, 1.332389510222689@2000-01-01 04:58:08.794345+01, 2@2000-01-02 00:00:00+01] query I SELECT round(exp(tfloat '[0@2000-01-01, 1@2000-01-02]'), 6); ---- -[1@2000-01-01 00:00:00+01, 2.718282@2000-01-02 00:00:00+01] +[1@2000-01-01 00:00:00+01, 1.718282@2000-01-01 12:59:30.467438+01, 2.718282@2000-01-02 00:00:00+01] # deltaValue — successive differences diff --git a/test/sql/parity/030_temporal_compops.test b/test/sql/parity/030_temporal_compops.test index dd9136b9..5d867c41 100644 --- a/test/sql/parity/030_temporal_compops.test +++ b/test/sql/parity/030_temporal_compops.test @@ -1,7 +1,7 @@ # name: test/sql/parity/030_temporal_compops.test -# description: Temporal comparison predicates returning Temporal — temporal_teq, -# temporal_tne, temporal_tlt, temporal_tle, temporal_tgt, -# temporal_tge across (base × t, t × base, t × t). +# description: Temporal comparison predicates returning Temporal — tEq, +# tNe, tLt, tLe, tGt, +# tGe across (base × t, t × base, t × t). # MobilityDB also exposes these as `?=`/`?<>`/`?<` etc. operators; # DuckDB's parser does not accept multi-character operator tokens # (`?=`, `#=`), so only the named functions are registered here. @@ -9,80 +9,80 @@ require mobilityduck -# temporal_teq with value × t (tint side) +# tEq with value × t (tint side) query I -SELECT temporal_teq(1, tint '[1@2000-01-01, 2@2000-01-02]'); +SELECT tEq(1, tint '[1@2000-01-01, 2@2000-01-02]'); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] query I -SELECT temporal_teq(tint '[1@2000-01-01, 2@2000-01-02]', 1); +SELECT tEq(tint '[1@2000-01-01, 2@2000-01-02]', 1); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] -# temporal_teq on tbool +# tEq on tbool query I -SELECT temporal_teq(true, tbool '[t@2000-01-01, f@2000-01-02]'); +SELECT tEq(true, tbool '[t@2000-01-01, f@2000-01-02]'); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] -# temporal_teq on tfloat (continuous interpolation crosses the threshold) +# tEq on tfloat (continuous interpolation crosses the threshold) query I -SELECT temporal_teq(2.5, tfloat '[1@2000-01-01, 5@2000-01-03]'); +SELECT tEq(2.5, tfloat '[1@2000-01-01, 5@2000-01-03]'); ---- {[f@2000-01-01 00:00:00+01, t@2000-01-01 18:00:00+01], (f@2000-01-01 18:00:00+01, f@2000-01-03 00:00:00+01]} -# temporal_teq on ttext +# tEq on ttext query I -SELECT temporal_tne('hello', ttext '["hello"@2000-01-01, "world"@2000-01-02]'); +SELECT tNe('hello', ttext '["hello"@2000-01-01, "world"@2000-01-02]'); ---- [f@2000-01-01 00:00:00+01, t@2000-01-02 00:00:00+01] -# temporal_teq with two temporals (same shape) +# tEq with two temporals (same shape) query I -SELECT temporal_teq(tint '[1@2000-01-01, 2@2000-01-02]', tint '[1@2000-01-01, 3@2000-01-02]'); +SELECT tEq(tint '[1@2000-01-01, 2@2000-01-02]', tint '[1@2000-01-01, 3@2000-01-02]'); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] -# temporal_tlt — strict less-than +# tLt — strict less-than query I -SELECT temporal_tlt(tint '[1@2000-01-01, 5@2000-01-02]', 3); +SELECT tLt(tint '[1@2000-01-01, 5@2000-01-02]', 3); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] -# temporal_tle vs temporal_tlt at the boundary value +# tLe vs tLt at the boundary value query I -SELECT temporal_tle(tint '[3@2000-01-01]', 3); +SELECT tLe(tint '[3@2000-01-01]', 3); ---- [t@2000-01-01 00:00:00+01] query I -SELECT temporal_tlt(tint '[3@2000-01-01]', 3); +SELECT tLt(tint '[3@2000-01-01]', 3); ---- [f@2000-01-01 00:00:00+01] -# temporal_tge / temporal_tgt symmetric to tle / tlt +# tGe / tGt symmetric to tle / tlt query I -SELECT temporal_tge(tint '[3@2000-01-01]', 3); +SELECT tGe(tint '[3@2000-01-01]', 3); ---- [t@2000-01-01 00:00:00+01] query I -SELECT temporal_tgt(tint '[3@2000-01-01]', 3); +SELECT tGt(tint '[3@2000-01-01]', 3); ---- [f@2000-01-01 00:00:00+01] # Ordered comparisons on ttext query I -SELECT temporal_tlt(ttext '["a"@2000-01-01, "z"@2000-01-02]', 'm'); +SELECT tLt(ttext '["a"@2000-01-01, "z"@2000-01-02]', 'm'); ---- [t@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01] diff --git a/test/sql/parity/032_temporal_boxops_followups.test b/test/sql/parity/032_temporal_boxops_followups.test index b4262961..92f75082 100644 --- a/test/sql/parity/032_temporal_boxops_followups.test +++ b/test/sql/parity/032_temporal_boxops_followups.test @@ -1,6 +1,6 @@ # name: test/sql/parity/032_temporal_boxops_followups.test # description: Tail of temporal/032_temporal_boxops — named-function aliases -# (temporal_contains/contained/overlaps/adjacent) for the +# (contains/contained/overlaps/adjacent) for the # already-wired @>/<@/&&/-|- operators, plus tboxes / # splitNTboxes / splitEachNTboxes. # group: [sql] @@ -10,38 +10,38 @@ require mobilityduck # Named-function aliases agree with the operator forms query I -SELECT temporal_contains(tint '[1@2000-01-01, 5@2000-01-05]', tint '[2@2000-01-02, 3@2000-01-03]') +SELECT contains(tint '[1@2000-01-01, 5@2000-01-05]', tint '[2@2000-01-02, 3@2000-01-03]') = (tint '[1@2000-01-01, 5@2000-01-05]' @> tint '[2@2000-01-02, 3@2000-01-03]'); ---- true query I -SELECT temporal_contained(tint '[2@2000-01-02, 3@2000-01-03]', tint '[1@2000-01-01, 5@2000-01-05]') +SELECT contained(tint '[2@2000-01-02, 3@2000-01-03]', tint '[1@2000-01-01, 5@2000-01-05]') = (tint '[2@2000-01-02, 3@2000-01-03]' <@ tint '[1@2000-01-01, 5@2000-01-05]'); ---- true query I -SELECT temporal_overlaps(tint '[1@2000-01-01]', tint '[1@2000-01-01]'); +SELECT overlaps(tint '[1@2000-01-01]', tint '[1@2000-01-01]'); ---- true query I -SELECT temporal_adjacent(tint '[1@2000-01-01, 2@2000-01-02]', tint '[3@2000-01-03, 4@2000-01-04]'); +SELECT adjacent(tint '[1@2000-01-01, 2@2000-01-02]', tint '[3@2000-01-03, 4@2000-01-04]'); ---- -false +true # Aliases also work for (temporal × tstzspan) query I -SELECT temporal_contains(tstzspan '[2000-01-01, 2000-01-10]', tint '[3@2000-01-03, 4@2000-01-04]'); +SELECT contains(tstzspan '[2000-01-01, 2000-01-10]', tint '[3@2000-01-03, 4@2000-01-04]'); ---- true # Aliases on (tnumber × numspan) and (tnumber × tbox) query I -SELECT temporal_overlaps(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[2, 4)'); +SELECT overlaps(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[2, 4)'); ---- true diff --git a/test/sql/parity/032_temporal_same.test b/test/sql/parity/032_temporal_same.test index 1d28c758..d06dfcfc 100644 --- a/test/sql/parity/032_temporal_same.test +++ b/test/sql/parity/032_temporal_same.test @@ -1,7 +1,7 @@ -# name: test/sql/parity/032_temporal_same.test -# description: Same predicate (`~=`) and `temporal_same` named alias on +# name: test/sql/parity/032_same.test +# description: Same predicate (`~=`) and `same` named alias on # temporal × {temporal, tstzspan, numspan, tbox} (and reverses). -# Closes the deferral from PR #72: temporal_boxops `temporal_same` +# Closes the deferral from PR #72: temporal_boxops `same` # is the last named-alias gap in that section, requiring new # Same_* handlers (other 4 ops were already wired). # group: [sql] @@ -12,28 +12,28 @@ require mobilityduck query I SELECT (tint '[1@2000-01-01]' ~= tint '[1@2000-01-01]') - = temporal_same(tint '[1@2000-01-01]', tint '[1@2000-01-01]'); + = same(tint '[1@2000-01-01]', tint '[1@2000-01-01]'); ---- true # Same x temporal — different values query I -SELECT temporal_same(tint '[1@2000-01-01]', tint '[2@2000-01-02]'); +SELECT same(tint '[1@2000-01-01]', tint '[2@2000-01-02]'); ---- false # Same on tbool × tbool query I -SELECT temporal_same(tbool '[t@2000-01-01]', tbool '[t@2000-01-01]'); +SELECT same(tbool '[t@2000-01-01]', tbool '[t@2000-01-01]'); ---- true # Same on temporal × tstzspan (matching time domain) query I -SELECT temporal_same(tint '[1@2000-01-01]', tstzspan '[2000-01-01, 2000-01-01]'); +SELECT same(tint '[1@2000-01-01]', tstzspan '[2000-01-01, 2000-01-01]'); ---- true @@ -45,26 +45,26 @@ true # Same on tnumber × numspan (matching value domain) query I -SELECT temporal_same(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[1, 6)'); +SELECT same(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[1, 6)'); ---- true query I -SELECT temporal_same(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[2, 6)'); +SELECT same(tint '[1@2000-01-01, 5@2000-01-05]', intspan '[2, 6)'); ---- false # numspan × tnumber query I -SELECT temporal_same(intspan '[1, 6)', tint '[1@2000-01-01, 5@2000-01-05]'); +SELECT same(intspan '[1, 6)', tint '[1@2000-01-01, 5@2000-01-05]'); ---- true # Same on tnumber × tbox query I -SELECT temporal_same(tint '[1@2000-01-01, 5@2000-01-05]', +SELECT same(tint '[1@2000-01-01, 5@2000-01-05]', tbox 'TBOXINT XT([1, 6),[2000-01-01, 2000-01-05])'); ---- true @@ -72,7 +72,7 @@ true # tbox × tnumber query I -SELECT temporal_same(tbox 'TBOXINT XT([1, 6),[2000-01-01, 2000-01-05])', +SELECT same(tbox 'TBOXINT XT([1, 6),[2000-01-01, 2000-01-05])', tint '[1@2000-01-01, 5@2000-01-05]'); ---- true diff --git a/test/sql/parity/032_temporal_topops.test b/test/sql/parity/032_temporal_topops.test index 1a4df71d..dc0ef874 100644 --- a/test/sql/parity/032_temporal_topops.test +++ b/test/sql/parity/032_temporal_topops.test @@ -46,4 +46,4 @@ true query I SELECT tint '[1@2000-01-01, 5@2000-01-05]' -|- tstzspan '[2000-01-05, 2000-01-06]'; ---- -false +true diff --git a/test/sql/parity/034_temporal_posops.test b/test/sql/parity/034_temporal_posops.test index 23d00202..a697b37c 100644 --- a/test/sql/parity/034_temporal_posops.test +++ b/test/sql/parity/034_temporal_posops.test @@ -1,57 +1,55 @@ # name: test/sql/parity/034_temporal_posops.test -# description: Named-function aliases for the temporal position predicates — -# temporal_before/after/overbefore/overafter (time axis) and -# temporal_left/right/overleft/overright (numeric axis on -# tnumber × {numspan, tbox, tnumber}). +# description: Temporal position predicates — before/after/overbefore/overafter +# (time axis) and left/right/overleft/overright (numeric axis on +# tnumber × {numspan, tbox, tnumber}), bare canonical names. # group: [sql] require mobilityduck -# Time axis aliases agree with the existing named forms +# Time axis query I -SELECT temporal_before(tint '[1@2000-01-01]', tint '[1@2000-01-02]') - = before(tint '[1@2000-01-01]', tint '[1@2000-01-02]'); +SELECT before(tint '[1@2000-01-01]', tint '[1@2000-01-02]'); ---- true query I -SELECT temporal_after(tint '[1@2000-01-02]', tint '[1@2000-01-01]'); +SELECT after(tint '[1@2000-01-02]', tint '[1@2000-01-01]'); ---- true query I -SELECT temporal_overbefore(tstzspan '[2000-01-01, 2000-01-02]', tint '[1@2000-01-02]'); +SELECT overbefore(tstzspan '[2000-01-01, 2000-01-02]', tint '[1@2000-01-02]'); ---- true query I -SELECT temporal_overafter(tint '[1@2000-01-02]', tstzspan '[2000-01-01, 2000-01-02]'); +SELECT overafter(tint '[1@2000-01-02]', tstzspan '[2000-01-01, 2000-01-02]'); ---- true # Numeric axis on tnumber × numspan query I -SELECT temporal_left(tint '[1@2000-01-01]', intspan '[5, 10)'); +SELECT left(tint '[1@2000-01-01]', intspan '[5, 10)'); ---- true query I -SELECT temporal_right(tfloat '[10@2000-01-01]', floatspan '[1, 5)'); +SELECT right(tfloat '[10@2000-01-01]', floatspan '[1, 5)'); ---- true -# Aliases agree with the operator forms +# Bare names agree with the operator forms query I -SELECT temporal_left(tint '[1@2000-01-01]', intspan '[5, 10)') +SELECT left(tint '[1@2000-01-01]', intspan '[5, 10)') = (tint '[1@2000-01-01]' << intspan '[5, 10)'); ---- true query I -SELECT temporal_overleft(tint '[1@2000-01-01]', intspan '[5, 10)') +SELECT overleft(tint '[1@2000-01-01]', intspan '[5, 10)') = (tint '[1@2000-01-01]' &< intspan '[5, 10)'); ---- true @@ -59,13 +57,13 @@ true # Numeric axis on tnumber × tbox query I -SELECT temporal_left(tint '[1@2000-01-01]', tbox 'TBOXINT XT([5, 10),[2000-01-01, 2000-01-02])'); +SELECT left(tint '[1@2000-01-01]', tbox 'TBOXINT XT([5, 10),[2000-01-01, 2000-01-02])'); ---- true # Numeric axis on tnumber × tnumber query I -SELECT temporal_left(tint '[1@2000-01-01]', tint '[5@2000-01-01, 10@2000-01-02]'); +SELECT left(tint '[1@2000-01-01]', tint '[5@2000-01-01, 10@2000-01-02]'); ---- true diff --git a/test/sql/parity/038_temporal_similarity.test b/test/sql/parity/038_temporal_similarity.test index c2422465..f8057007 100644 --- a/test/sql/parity/038_temporal_similarity.test +++ b/test/sql/parity/038_temporal_similarity.test @@ -17,7 +17,7 @@ SELECT round(frechetDistance(tfloat '[1@2000-01-01, 4@2000-01-04]', tfloat '[2@2 1.000000 query I -SELECT round(dynTimeWarp(tint '[1@2000-01-01, 5@2000-01-05]', tint '[2@2000-01-01, 3@2000-01-03, 4@2000-01-05]')::numeric, 6); +SELECT round(dynTimeWarpDistance(tint '[1@2000-01-01, 5@2000-01-05]', tint '[2@2000-01-01, 3@2000-01-03, 4@2000-01-05]')::numeric, 6); ---- 4.000000 diff --git a/test/sql/parity/038b_similarity_followups.test b/test/sql/parity/038b_similarity_followups.test index 1fb1982f..baf24747 100644 --- a/test/sql/parity/038b_similarity_followups.test +++ b/test/sql/parity/038b_similarity_followups.test @@ -1,49 +1,44 @@ # name: test/sql/parity/038b_similarity_followups.test -# description: dynTimeWarpDistance alias + frechetDistancePath + -# dynTimeWarpPath (tnumber and tgeompoint). +# description: dynTimeWarpDistance + frechetDistancePath / dynTimeWarpPath +# (tnumber and tgeompoint), canonical names + SETOF (table) form. # group: [sql] require mobilityduck -# dynTimeWarpDistance: MobilityDB-canonical name, same handler as dynTimeWarp +# dynTimeWarpDistance: the MobilityDB-canonical scalar distance query I SELECT dynTimeWarpDistance(tfloat '[1@2000-01-01, 2@2000-01-02, 3@2000-01-03]', tfloat '[1@2000-01-01, 3@2000-01-03]'); ---- 0 -# Equivalence with the existing alias +# frechetDistancePath: RETURNS SETOF warp(i, j) -> DuckDB table function -query I -SELECT dynTimeWarpDistance(tfloat '[1@2000-01-01, 5@2000-01-02]', tfloat '[2@2000-01-01, 3@2000-01-02]') - = dynTimeWarp(tfloat '[1@2000-01-01, 5@2000-01-02]', tfloat '[2@2000-01-01, 3@2000-01-02]'); +query II +SELECT i, j FROM frechetDistancePath(tfloat '[1@2000-01-01, 2@2000-01-02, 3@2000-01-03]', tfloat '[1@2000-01-01, 3@2000-01-03]') ORDER BY i, j; ---- -true - -# frechetDistancePath returns LIST(STRUCT(i INTEGER, j INTEGER)) - -query I -SELECT frechetDistancePath(tfloat '[1@2000-01-01, 2@2000-01-02, 3@2000-01-03]', tfloat '[1@2000-01-01, 3@2000-01-03]'); ----- -[{'i': 1, 'j': 1}, {'i': 0, 'j': 0}] +0 0 +1 1 # dynTimeWarpPath same shape -query I -SELECT dynTimeWarpPath(tfloat '[1@2000-01-01, 2@2000-01-02, 3@2000-01-03]', tfloat '[1@2000-01-01, 3@2000-01-03]'); +query II +SELECT i, j FROM dynTimeWarpPath(tfloat '[1@2000-01-01, 2@2000-01-02, 3@2000-01-03]', tfloat '[1@2000-01-01, 3@2000-01-03]') ORDER BY i, j; ---- -[{'i': 1, 'j': 1}, {'i': 0, 'j': 0}] +0 0 +1 1 # Path on tgeompoint trajectories -query I -SELECT frechetDistancePath(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', tgeompoint '[POINT(0 0)@2000-01-01, POINT(2 2)@2000-01-02]'); +query II +SELECT i, j FROM frechetDistancePath(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', tgeompoint '[POINT(0 0)@2000-01-01, POINT(2 2)@2000-01-02]') ORDER BY i, j; ---- -[{'i': 1, 'j': 1}, {'i': 0, 'j': 0}] +0 0 +1 1 # Path length matches min(n1, n2) for already-aligned inputs query I -SELECT len(dynTimeWarpPath(tfloat '[1@2000-01-01, 2@2000-01-02]', tfloat '[10@2000-01-01, 20@2000-01-02]')); +SELECT count(*)::int FROM dynTimeWarpPath(tfloat '[1@2000-01-01, 2@2000-01-02]', tfloat '[10@2000-01-01, 20@2000-01-02]'); ---- 2 diff --git a/test/sql/parity/040_tgeometry_parity.test b/test/sql/parity/040_tgeometry_parity.test index 219be30f..bc24d405 100644 --- a/test/sql/parity/040_tgeometry_parity.test +++ b/test/sql/parity/040_tgeometry_parity.test @@ -160,7 +160,7 @@ SELECT tempSubtype(t::tgeometry) FROM (VALUES Sequence # ============================================================================= -# Box predicates: temporal_overlaps / contains / contained / same / adjacent +# Box predicates: overlaps / contains / contained / same / adjacent # (named functions + the matching &&, @>, <@, ~=, -|- operators) # ============================================================================= @@ -171,13 +171,13 @@ SELECT t1::tgeometry && t2::tgeometry FROM (VALUES true query I -SELECT temporal_contains(t::tgeometry, '[2000-01-01, 2000-01-02]'::tstzspan) FROM +SELECT contains(t::tgeometry, '[2000-01-01, 2000-01-02]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true query I -SELECT temporal_same(t::tgeometry, t::tgeometry) FROM (VALUES +SELECT same(t::tgeometry, t::tgeometry) FROM (VALUES ('Point(0 0)@2000-01-01')) t(t); ---- true @@ -187,19 +187,19 @@ true # ============================================================================= query I -SELECT temporal_left(t1::tgeometry, t2::tgeometry) FROM (VALUES +SELECT left(t1::tgeometry, t2::tgeometry) FROM (VALUES ('Point(0 0)@2000-01-01', 'Point(5 5)@2000-01-01')) t(t1, t2); ---- true query I -SELECT temporal_below(t1::tgeometry, t2::tgeometry) FROM (VALUES +SELECT below(t1::tgeometry, t2::tgeometry) FROM (VALUES ('Point(0 0)@2000-01-01', 'Point(0 5)@2000-01-01')) t(t1, t2); ---- true query I -SELECT temporal_before(t::tgeometry, '[2000-01-05, 2000-01-06]'::tstzspan) FROM +SELECT before(t::tgeometry, '[2000-01-05, 2000-01-06]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true diff --git a/test/sql/parity/041_tgeography_parity.test b/test/sql/parity/041_tgeography_parity.test index e53e5657..e9cb896b 100644 --- a/test/sql/parity/041_tgeography_parity.test +++ b/test/sql/parity/041_tgeography_parity.test @@ -95,7 +95,7 @@ SELECT t1::tgeography && t2::tgeography FROM (VALUES true query I -SELECT temporal_contains(t::tgeography, '[2000-01-01, 2000-01-02]'::tstzspan) FROM +SELECT contains(t::tgeography, '[2000-01-01, 2000-01-02]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true @@ -105,7 +105,7 @@ true # ============================================================================= query I -SELECT temporal_before(t::tgeography, '[2000-01-05, 2000-01-06]'::tstzspan) FROM +SELECT before(t::tgeography, '[2000-01-05, 2000-01-06]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true diff --git a/test/sql/parity/042_tgeogpoint_parity.test b/test/sql/parity/042_tgeogpoint_parity.test index 7ba3879f..092ff529 100644 --- a/test/sql/parity/042_tgeogpoint_parity.test +++ b/test/sql/parity/042_tgeogpoint_parity.test @@ -88,7 +88,7 @@ SELECT t1::tgeogpoint && t2::tgeogpoint FROM (VALUES true query I -SELECT temporal_contains(t::tgeogpoint, '[2000-01-01, 2000-01-02]'::tstzspan) FROM +SELECT contains(t::tgeogpoint, '[2000-01-01, 2000-01-02]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true @@ -98,7 +98,7 @@ true # ============================================================================= query I -SELECT temporal_before(t::tgeogpoint, '[2000-01-05, 2000-01-06]'::tstzspan) FROM +SELECT before(t::tgeogpoint, '[2000-01-05, 2000-01-06]'::tstzspan) FROM (VALUES ('[Point(0 0)@2000-01-01, Point(2 2)@2000-01-03]')) t(t); ---- true diff --git a/test/sql/parity/054_tspatial_compops.test b/test/sql/parity/054_tspatial_compops.test index 3141d72f..44cdc017 100644 --- a/test/sql/parity/054_tspatial_compops.test +++ b/test/sql/parity/054_tspatial_compops.test @@ -1,60 +1,60 @@ # name: test/sql/parity/054_tspatial_compops.test # description: Tspatial × {geometry, tspatial} comparison predicates — -# ever_eq / always_eq / ever_ne / always_ne and temporal_teq / -# temporal_tne. The MobilityDB operators `?=` / `?<>` / `#=` etc. +# eEq / aEq / eNe / aNe and tEq / +# tNe. The MobilityDB operators `?=` / `?<>` / `#=` etc. # are unreachable in DuckDB's parser, so only named functions # are registered. # group: [sql] require mobilityduck -# ever_eq across (geo × tgeo, tgeo × geo, tgeo × tgeo) +# eEq across (geo × tgeo, tgeo × geo, tgeo × tgeo) query I -SELECT ever_eq(ST_GeomFromText('POINT(0 0)'), tgeompoint '[POINT(0 0)@2000-01-01]'); +SELECT eEq(ST_GeomFromText('POINT(0 0)'), tgeompoint '[POINT(0 0)@2000-01-01]'); ---- true query I -SELECT ever_eq(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', ST_GeomFromText('POINT(0 0)')); +SELECT eEq(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', ST_GeomFromText('POINT(0 0)')); ---- true query I -SELECT ever_eq(tgeompoint '[POINT(0 0)@2000-01-01]', tgeompoint '[POINT(0 0)@2000-01-01]'); +SELECT eEq(tgeompoint '[POINT(0 0)@2000-01-01]', tgeompoint '[POINT(0 0)@2000-01-01]'); ---- true -# always_eq / ever_ne / always_ne +# aEq / eNe / aNe query I -SELECT always_eq(tgeompoint '[POINT(5 5)@2000-01-01]', ST_GeomFromText('POINT(5 5)')); +SELECT aEq(tgeompoint '[POINT(5 5)@2000-01-01]', ST_GeomFromText('POINT(5 5)')); ---- true query I -SELECT ever_ne(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', ST_GeomFromText('POINT(0 0)')); +SELECT eNe(tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]', ST_GeomFromText('POINT(0 0)')); ---- true query I -SELECT always_ne(ST_GeomFromText('POINT(5 5)'), tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]'); +SELECT aNe(ST_GeomFromText('POINT(5 5)'), tgeompoint '[POINT(0 0)@2000-01-01, POINT(1 1)@2000-01-02]'); ---- true -# temporal_teq returns tbool with t/f along the trajectory +# tEq returns tbool with t/f along the trajectory query I -SELECT temporal_teq(tgeompoint '[POINT(0 0)@2000-01-01]', tgeompoint '[POINT(0 0)@2000-01-01]'); +SELECT tEq(tgeompoint '[POINT(0 0)@2000-01-01]', tgeompoint '[POINT(0 0)@2000-01-01]'); ---- [t@2000-01-01 00:00:00+01] query I -SELECT temporal_teq(tgeompoint '[POINT(0 0)@2000-01-01]', ST_GeomFromText('POINT(0 0)')); +SELECT tEq(tgeompoint '[POINT(0 0)@2000-01-01]', ST_GeomFromText('POINT(0 0)')); ---- {[t@2000-01-01 00:00:00+01]} query I -SELECT temporal_tne(ST_GeomFromText('POINT(5 5)'), tgeompoint '[POINT(0 0)@2000-01-01]'); +SELECT tNe(ST_GeomFromText('POINT(5 5)'), tgeompoint '[POINT(0 0)@2000-01-01]'); ---- {[t@2000-01-01 00:00:00+01]} diff --git a/test/sql/parity/060_tspatial_topops.test b/test/sql/parity/060_tspatial_topops.test index 84aed0f4..f9198bfc 100644 --- a/test/sql/parity/060_tspatial_topops.test +++ b/test/sql/parity/060_tspatial_topops.test @@ -1,7 +1,8 @@ # name: test/sql/parity/060_tspatial_topops.test -# description: Tspatial × {stbox, tspatial} topological predicates — -# temporal_contains/contained/overlaps/same/adjacent and the -# corresponding @>/<@/&&/~=/-|- operator forms. +# description: Tspatial × {stbox, tspatial} topological predicates — the canonical +# bare functions contains/contained/overlaps/same/adjacent (the names +# MobilityDB deploys in .in.sql) and the corresponding @>/<@/&&/~=/-|- +# operator forms. Both surfaces are generated from the MEOS-API catalog. # group: [sql] require mobilityduck @@ -11,16 +12,16 @@ require mobilityduck query I SELECT (tgeompoint '[POINT(0 0)@2000-01-01, POINT(10 10)@2000-01-02]' @> stbox 'STBOX X((1, 1), (5, 5))') - = temporal_contains(tgeompoint '[POINT(0 0)@2000-01-01, POINT(10 10)@2000-01-02]', - stbox 'STBOX X((1, 1), (5, 5))'); + = contains(tgeompoint '[POINT(0 0)@2000-01-01, POINT(10 10)@2000-01-02]', + stbox 'STBOX X((1, 1), (5, 5))'); ---- true # stbox × tspatial direction query I -SELECT temporal_overlaps(stbox 'STBOX X((0, 0), (10, 10))', - tgeompoint '[POINT(5 5)@2000-01-01]'); +SELECT overlaps(stbox 'STBOX X((0, 0), (10, 10))', + tgeompoint '[POINT(5 5)@2000-01-01]'); ---- true @@ -32,8 +33,8 @@ true # Same on tgeompoint × tgeompoint query I -SELECT temporal_same(tgeompoint '[POINT(0 0)@2000-01-01]', - tgeompoint '[POINT(0 0)@2000-01-01]'); +SELECT same(tgeompoint '[POINT(0 0)@2000-01-01]', + tgeompoint '[POINT(0 0)@2000-01-01]'); ---- true @@ -42,31 +43,31 @@ SELECT (tgeompoint '[POINT(0 0)@2000-01-01]' ~= tgeompoint '[POINT(0 0)@2000-01- ---- true -# Disjoint trajectories: not same, not contains +# Disjoint trajectories: not same (differing SPACE at the same instant) query I -SELECT temporal_same(tgeompoint '[POINT(0 0)@2000-01-01]', - tgeompoint '[POINT(1 1)@2000-01-01]'); +SELECT same(tgeompoint '[POINT(0 0)@2000-01-01]', + tgeompoint '[POINT(1 1)@2000-01-01]'); ---- false # Adjacent — point on the box corner shares the boundary query I -SELECT temporal_adjacent(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((0, 0), (5, 5))'); +SELECT adjacent(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((0, 0), (5, 5))'); ---- true # Contains via stbox × tspatial query I -SELECT temporal_contains(stbox 'STBOX X((0, 0), (10, 10))', tgeompoint '[POINT(5 5)@2000-01-01]'); +SELECT contains(stbox 'STBOX X((0, 0), (10, 10))', tgeompoint '[POINT(5 5)@2000-01-01]'); ---- true # Contained as the inverse query I -SELECT temporal_contained(tgeompoint '[POINT(5 5)@2000-01-01]', stbox 'STBOX X((0, 0), (10, 10))'); +SELECT contained(tgeompoint '[POINT(5 5)@2000-01-01]', stbox 'STBOX X((0, 0), (10, 10))'); ---- true diff --git a/test/sql/parity/061_tspatial_bbox_dimension.test b/test/sql/parity/061_tspatial_bbox_dimension.test new file mode 100644 index 00000000..c497e963 --- /dev/null +++ b/test/sql/parity/061_tspatial_bbox_dimension.test @@ -0,0 +1,71 @@ +# name: test/sql/parity/061_tspatial_bbox_dimension.test +# description: Regression — the bounding-box topological ops (operators ~=/@>/<@/&&/-|- +# and their canonical functions same/contains/…) must compare the FULL +# bounding box of each type, not only its time dimension. tspatial → +# space+time (stbox), tnumber incl. tbigint → value+time (tbox), tbool/ttext +# → time only (tstzspan). Guards against the generic *_temporal_temporal +# (time-only) op shadowing the type-specific *_tspatial_tspatial / +# *_tnumber_tnumber backing. Uses the canonical bare name `same` (the +# deployed MobilityDB SQL name), NOT the catalog-only `same_bbox` @sqlfn tag. +# group: [sql] + +require mobilityduck + +# --- tspatial: the SPACE dimension must count (differing X, identical instant) --- + +query I +SELECT tgeompoint 'POINT(0 0)@2000-01-01' ~= tgeompoint 'POINT(1 1)@2000-01-01'; +---- +false + +query I +SELECT same(tgeompoint 'POINT(0 0)@2000-01-01', tgeompoint 'POINT(1 1)@2000-01-01'); +---- +false + +query I +SELECT tgeompoint 'POINT(0 0)@2000-01-01' ~= tgeompoint 'POINT(0 0)@2000-01-01'; +---- +true + +# Different X, different instant: still not the same box +query I +SELECT tgeompoint '[POINT(0 0)@2000-01-01]' ~= tgeompoint '[POINT(9 9)@2000-01-09]'; +---- +false + +# Spatial containment via the box operators +query I +SELECT tgeompoint '[POINT(0 0)@2000-01-01, POINT(10 10)@2000-01-02]' @> stbox 'STBOX X((1, 1), (5, 5))'; +---- +true + +query I +SELECT tgeompoint '[POINT(0 0)@2000-01-01, POINT(2 2)@2000-01-02]' @> stbox 'STBOX X((1, 1), (5, 5))'; +---- +false + +# --- tnumber: the VALUE dimension must count (differing value, identical instant) --- + +query I +SELECT tint '1@2000-01-01' ~= tint '9@2000-01-01'; +---- +false + +# tbigint is a tnumber (tbox = value+time) — value must count, not only time +query I +SELECT tbigint '1@2000-01-01' ~= tbigint '9@2000-01-01'; +---- +false + +# --- tbool: bbox is purely temporal — value has no bbox dimension, only time counts --- + +query I +SELECT tbool 'true@2000-01-01' ~= tbool 'false@2000-01-01'; +---- +true + +query I +SELECT tbool 'true@2000-01-01' ~= tbool 'true@2000-01-02'; +---- +false diff --git a/test/sql/parity/062_tspatial_posops.test b/test/sql/parity/062_tspatial_posops.test index e6269b58..8fb014f2 100644 --- a/test/sql/parity/062_tspatial_posops.test +++ b/test/sql/parity/062_tspatial_posops.test @@ -8,15 +8,15 @@ require mobilityduck -# X-axis: temporal_left / temporal_overright +# X-axis: left / overright query I -SELECT temporal_left(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((5, 0), (10, 5))'); +SELECT left(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((5, 0), (10, 5))'); ---- true query I -SELECT temporal_overright(tgeompoint '[POINT(10 10)@2000-01-01]', stbox 'STBOX X((0, 0), (10, 10))'); +SELECT overright(tgeompoint '[POINT(10 10)@2000-01-01]', stbox 'STBOX X((0, 0), (10, 10))'); ---- true @@ -24,47 +24,47 @@ true query I SELECT (tgeompoint '[POINT(0 0)@2000-01-01]' << stbox 'STBOX X((5, 0), (10, 5))') - = temporal_left(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((5, 0), (10, 5))'); + = left(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((5, 0), (10, 5))'); ---- true # Y-axis (named-only) query I -SELECT temporal_below(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((0, 5), (10, 10))'); +SELECT below(tgeompoint '[POINT(0 0)@2000-01-01]', stbox 'STBOX X((0, 5), (10, 10))'); ---- true query I -SELECT temporal_above(stbox 'STBOX X((0, 0), (10, 5))', tgeompoint '[POINT(5 10)@2000-01-01]'); +SELECT above(stbox 'STBOX X((0, 0), (10, 5))', tgeompoint '[POINT(5 10)@2000-01-01]'); ---- false # Z-axis: requires 3D inputs query I -SELECT temporal_front(tgeompoint '[POINT Z (0 0 0)@2000-01-01]', stbox 'STBOX Z((0, 0, 5), (10, 10, 10))'); +SELECT front(tgeompoint '[POINT Z (0 0 0)@2000-01-01]', stbox 'STBOX Z((0, 0, 5), (10, 10, 10))'); ---- true # tspatial × tspatial query I -SELECT temporal_left(tgeompoint '[POINT(0 0)@2000-01-01]', +SELECT left(tgeompoint '[POINT(0 0)@2000-01-01]', tgeompoint '[POINT(5 5)@2000-01-01, POINT(10 10)@2000-01-02]'); ---- true -# Time-axis: temporal_before / temporal_overafter +# Time-axis: before / overafter query I -SELECT temporal_before(tgeompoint '[POINT(5 5)@2000-01-01]', +SELECT before(tgeompoint '[POINT(5 5)@2000-01-01]', stbox 'STBOX XT(((0, 0), (10, 10)), [2000-01-02, 2000-01-03])'); ---- true query I -SELECT temporal_overafter(tgeompoint '[POINT(5 5)@2000-01-03]', +SELECT overafter(tgeompoint '[POINT(5 5)@2000-01-03]', stbox 'STBOX XT(((0, 0), (10, 10)), [2000-01-01, 2000-01-02])'); ---- true @@ -72,7 +72,7 @@ true # tspatial × tspatial time-axis query I -SELECT temporal_after(tgeompoint '[POINT(5 5)@2000-01-03]', +SELECT after(tgeompoint '[POINT(5 5)@2000-01-03]', tgeompoint '[POINT(0 0)@2000-01-01]'); ---- true diff --git a/test/sql/set.test b/test/sql/set.test index ac8c2ff8..035d3b7a 100644 --- a/test/sql/set.test +++ b/test/sql/set.test @@ -354,7 +354,7 @@ SELECT asText(textset '{"highway","car"}' || '_suf'); # Set operators (MEOS): contains, overlaps, union with value, distance query I -SELECT set_contains(intset '{1,2,3}', 2); +SELECT contains(intset '{1,2,3}', 2); ---- true @@ -422,3 +422,20 @@ query I SELECT dateset '{2000-01-01}' >= dateset '{2000-01-01, 2000-01-02, 2000-01-03}'; ---- false + +# FromHexWKB parsers (per-element-type name family, generated). The strings are the +# MEOS hex-WKB encodings of the corresponding literals. +query I +SELECT intsetFromHexWKB('0112000103000000010000000200000003000000') = intset '{1, 2, 3}'; +---- +true + +query I +SELECT floatsetFromHexWKB('010C000102000000000000000000F83F0000000000000440') = floatset '{1.5, 2.5}'; +---- +true + +query I +SELECT textsetFromHexWKB('0120000102000000010000000000000061010000000000000062') = textset '{"a", "b"}'; +---- +true diff --git a/test/sql/span.test b/test/sql/span.test index 2a18259b..4a452716 100644 --- a/test/sql/span.test +++ b/test/sql/span.test @@ -244,11 +244,23 @@ SELECT round(floatspan '[1.5, 2.5]'); [2, 3] query I -SELECT span_contains(floatspan '[1.5, 2.5]', 1.5); +SELECT contains(floatspan '[1.5, 2.5]', 1.5); ---- true -query I -SELECT span_contained(1.5, floatspan '[1.5, 2.5]'); +query I +SELECT contained(1.5, floatspan '[1.5, 2.5]'); +---- +true + +# FromHexWKB parsers (per-element-type name family, generated). The strings are the +# MEOS hex-WKB encodings of the corresponding literals. +query I +SELECT intspanFromHexWKB('011300010100000005000000') = intspan '[1, 5)'; +---- +true + +query I +SELECT floatspanFromHexWKB('010D0003000000000000F83F0000000000000C40') = floatspan '[1.5, 3.5]'; ---- true diff --git a/test/sql/spanset.test b/test/sql/spanset.test index fc2afa81..3d1c4a37 100644 --- a/test/sql/spanset.test +++ b/test/sql/spanset.test @@ -509,7 +509,19 @@ SELECT floatspanset '{[1,1]}' > floatspanset '{[1,2),[2,3),[3,4)}'; ---- false -query I +query I SELECT floatspanset '{[1,1]}' >= floatspanset '{[1,2),[2,3),[3,4)}'; ---- false + +# FromHexWKB parsers (per-element-type name family, generated). The strings are the +# MEOS hex-WKB encodings of the corresponding literals. +query I +SELECT intspansetFromHexWKB('01140002000000010100000003000000010500000007000000') = intspanset '{[1, 3), [5, 7)}'; +---- +true + +query I +SELECT floatspansetFromHexWKB('010E000200000003000000000000F83F0000000000000440030000000000000C400000000000001240') = floatspanset '{[1.5, 2.5], [3.5, 4.5]}'; +---- +true diff --git a/test/sql/tbool.test b/test/sql/tbool.test index 1eee1849..31257f1e 100644 --- a/test/sql/tbool.test +++ b/test/sql/tbool.test @@ -170,7 +170,31 @@ SELECT temporal_cmp(tbool 't@2000-01-01', tbool 't@2000-01-01'); ---- 0 -query I +query I SELECT tbool 't@2000-01-01' = tbool '{[t@2000-01-01, f@2000-01-02, t@2000-01-03],[t@2000-01-04, t@2000-01-05]}'; ---- false + +# tsequenceset_make_gaps: tbool has only the maxt (time-gap) overload; a value distance is undefined. +query I +SELECT tboolSeqSetGaps([tbool 't@2000-01-01', tbool 'f@2000-01-10'], interval '3 days'); +---- +{[t@2000-01-01 00:00:00+01], [f@2000-01-10 00:00:00+01]} + +# From MF-JSON / HexWKB parsers (generated base-type name family). Strings are the +# MEOS encodings of the corresponding literals (Europe/Brussels session tz). +query I +SELECT tboolFromMFJSON('{"type":"MovingBoolean","values":[true],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') = tbool 't@2000-01-01'; +---- +true + +query I +SELECT tboolFromHexWKB('011A000101005C6C29FFFFFFFF') = tbool 't@2000-01-01'; +---- +true + +# asHexWKB output (base hex-WKB) — generated inherited Temporal surface. Round-trips. +query I +SELECT tboolFromHexWKB(asHexWKB(tbool 't@2000-01-01')) = tbool 't@2000-01-01'; +---- +true diff --git a/test/sql/tcbuffer.test b/test/sql/tcbuffer.test new file mode 100644 index 00000000..921fd0a9 --- /dev/null +++ b/test/sql/tcbuffer.test @@ -0,0 +1,162 @@ +# name: test/sql/tcbuffer.test +# description: Circular-buffer temporal type (cbuffer / tcbuffer) — type + text I/O and +# the catalog-generated operation surface. + +require mobilityduck + +# --------------------------------------------------------------------------- +# Type + text I/O (hand-registered boundary; the point renders as HEXEWKB, the +# canonical #Cbuffer_out() form — asText produces the WKT POINT(..) form). +# --------------------------------------------------------------------------- + +# Static cbuffer value round-trip +query I +SELECT cbuffer 'Cbuffer(Point(1 1),0.5)'; +---- +Cbuffer(0101000000000000000000F03F000000000000F03F,0.5) + +# tcbuffer instant round-trip +query I +SELECT tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'; +---- +Cbuffer(0101000000000000000000F03F000000000000F03F,0.5)@2000-01-01 00:00:00+01 + +# tcbuffer sequence round-trip +query I +SELECT tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'; +---- +{Cbuffer(0101000000000000000000F03F000000000000F03F,0.5)@2000-01-01 00:00:00+01, Cbuffer(010100000000000000000000400000000000000040,1)@2000-01-02 00:00:00+01} + +# --------------------------------------------------------------------------- +# Catalog-generated operation surface (accessors, conversions, distance, +# spatial relationships) — one thin marshalling shell per MEOS function. +# --------------------------------------------------------------------------- + +# Accessor: number of instants +query I +SELECT numInstants(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'); +---- +2 + +# Accessor: start instant (returns a tcbuffer) +query I +SELECT startInstant(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'); +---- +Cbuffer(0101000000000000000000F03F000000000000F03F,0.5)@2000-01-01 00:00:00+01 + +# Conversion: the radius as a tfloat +query I +SELECT tfloat(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'); +---- +{0.5@2000-01-01 00:00:00+01, 1@2000-01-02 00:00:00+01} + +# Conversion: the centre trajectory as a tgeompoint +query I +SELECT asText(tgeompoint(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}')); +---- +{POINT(1 1)@2000-01-01 00:00:00+01, POINT(2 2)@2000-01-02 00:00:00+01} + +# Temporal distance (Point(0 0) to Point(3 4), radii 0) = 5 +query I +SELECT tDistance(tcbuffer 'Cbuffer(Point(0 0),0)@2000-01-01', tcbuffer 'Cbuffer(Point(3 4),0)@2000-01-01'); +---- +5@2000-01-01 00:00:00+01 + +# Ever intersects itself +query I +SELECT eIntersects(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01', tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'); +---- +true + +# Ever dwithin 1.0 of a far buffer -> false +query I +SELECT eDwithin(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01', tcbuffer 'Cbuffer(Point(5 5),0.5)@2000-01-01', 1.0); +---- +false + +# --------------------------------------------------------------------------- +# Inherited TSpatial + Temporal surface — tcbuffer is a TSpatial subtype, +# so it inherits the spatial (asText/asEWKT/SRID/topological) and generic temporal +# (duration/atTime) behaviour previously confined to the geo types. +# --------------------------------------------------------------------------- + +# asText -> WKT point form (vs the hexewkb of the plain output cast) +query I +SELECT asText(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'); +---- +Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# asEWKT +query I +SELECT asEWKT(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'); +---- +Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01 + +# SRID (unset -> 0) +query I +SELECT SRID(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'); +---- +0 + +# duration of a continuous sequence +query I +SELECT duration(tcbuffer '[Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(3 3),1.5)@2000-01-03]'); +---- +2 days + +# atTime restricts to a period, interpolating the buffer at the endpoint +query I +SELECT asText(atTime(tcbuffer '[Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(3 3),1.5)@2000-01-03]', tstzspan '[2000-01-01,2000-01-02]')); +---- +[Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01, Cbuffer(POINT(2 2),1)@2000-01-02 00:00:00+01] + +# base-value accessors (Temporal: startValue/endValue return the base value = a cbuffer, +# rendered by the cbuffer output cast in the canonical HEXEWKB point form) +query I +SELECT startValue(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'); +---- +Cbuffer(0101000000000000000000F03F000000000000F03F,0.5) + +query I +SELECT endValue(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}'); +---- +Cbuffer(010100000000000000000000400000000000000040,1) + +# spatial accessor: convex hull of the swept region. convexHull is a linear (GEOS-polygonized) +# hull of the traversed area, not a curved CURVEDPOLYGON (see the tcbuffer manual note); a +# zero-radius input yields the point trajectory's stable, arc-free triangle. The geometry +# marshals to the DuckDB GEOMETRY type. +query I +SELECT ST_AsText(convexHull(tcbuffer '[Cbuffer(Point(0 0),0)@2000-01-01, Cbuffer(Point(3 0),0)@2000-01-02, Cbuffer(Point(3 4),0)@2000-01-03]')); +---- +POLYGON ((0 0, 3 4, 3 0, 0 0)) + +# range restriction by a base value (Temporal, T): atValue keeps the instants whose value +# equals the cbuffer, minusValue keeps the complement. The cbuffer 2nd operand is marshalled +# from its blob, so the whole (tcbuffer, cbuffer) binary surface is generated uniformly. +query I +SELECT asText(atValue(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}', cbuffer 'Cbuffer(Point(1 1),0.5)')); +---- +{Cbuffer(POINT(1 1),0.5)@2000-01-01 00:00:00+01} + +query I +SELECT asText(minusValue(tcbuffer '{Cbuffer(Point(1 1),0.5)@2000-01-01, Cbuffer(Point(2 2),1.0)@2000-01-02}', cbuffer 'Cbuffer(Point(1 1),0.5)')); +---- +{Cbuffer(POINT(2 2),1)@2000-01-02 00:00:00+01} + +# spatial relationship against a static cbuffer value (same (tcbuffer, cbuffer) shape) +query I +SELECT eIntersects(tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01', cbuffer 'Cbuffer(Point(1 1),0.5)'); +---- +true + +# inherited bbox topological operators (same, overlaps) +query I +SELECT tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01' ~= tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'; +---- +true + +query I +SELECT tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01' && tcbuffer 'Cbuffer(Point(1 1),0.5)@2000-01-01'; +---- +true diff --git a/test/sql/tfloat.test b/test/sql/tfloat.test index 80eaa7b0..a6ba46bb 100644 --- a/test/sql/tfloat.test +++ b/test/sql/tfloat.test @@ -27,7 +27,7 @@ SELECT tempDump(tfloat '[1.5@2001-01-01, 2.5@2001-01-02, 1.5@2001-01-03]'); [{'value': 1.5, 'time': '{[2001-01-01 00:00:00+01, 2001-01-01 00:00:00+01], [2001-01-03 00:00:00+01, 2001-01-03 00:00:00+01]}'}, {'value': 2.5, 'time': '{[2001-01-02 00:00:00+01, 2001-01-02 00:00:00+01]}'}] query I -SELECT atValues(tfloat 'Interp=Step;{[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03],[3.5@2000-01-04, 3.5@2000-01-05]}', floatspan '[1,3]'); +SELECT atSpan(tfloat 'Interp=Step;{[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03],[3.5@2000-01-04, 3.5@2000-01-05]}', floatspan '[1,3]'); ---- Interp=Step;{[1.5@2000-01-01 00:00:00+01, 2.5@2000-01-02 00:00:00+01, 1.5@2000-01-03 00:00:00+01]} @@ -139,12 +139,12 @@ SELECT minusValues(tfloat '{1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03}', fl {2.5@2000-01-02 00:00:00+01} query I -SELECT atValues(tfloat '[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03]', floatspan '[1,3]'); +SELECT atSpan(tfloat '[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03]', floatspan '[1,3]'); ---- {[1.5@2000-01-01 00:00:00+01, 2.5@2000-01-02 00:00:00+01, 1.5@2000-01-03 00:00:00+01]} query I -SELECT atValues(tfloat '{[1@2000-01-01, 3@2000-01-03],[4@2000-01-04]}', floatspanset '{[1,2],[3,4]}'); +SELECT atSpanset(tfloat '{[1@2000-01-01, 3@2000-01-03],[4@2000-01-04]}', floatspanset '{[1,2],[3,4]}'); ---- {[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01], [3@2000-01-03 00:00:00+01], [4@2000-01-04 00:00:00+01]} @@ -211,7 +211,7 @@ SELECT segmentMinDuration(tfloat 'Interp=Step;{[1.5@2000-01-01, 2.5@2000-01-02, ---- {[f@2000-01-01 00:00:00+01, f@2000-01-03 00:00:00+01), [f@2000-01-04 00:00:00+01, f@2000-01-05 00:00:00+01)} -query I +query I SELECT segmentMaxDuration(tfloat '{[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03],[3.5@2000-01-04, 3.5@2000-01-05]}', '1 day'); ---- {[f@2000-01-01 00:00:00+01, f@2000-01-03 00:00:00+01), [f@2000-01-04 00:00:00+01, f@2000-01-05 00:00:00+01)} @@ -231,7 +231,42 @@ SELECT tfloat '1.5@2000-01-01' > tfloat '{[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2 ---- false -query I +query I SELECT duration(tfloat 'Interp=Step;[1.5@2000-01-01, 2.5@2000-01-02, 1.5@2000-01-03]'); ---- 2 days + +# tsequenceset_make_gaps: split an array of instants into sequences at time gaps (> maxt) +# and/or value gaps (> maxdist). +query I +SELECT tfloatSeqSetGaps([tfloat '1@2000-01-01', tfloat '2@2000-01-02', tfloat '10@2000-01-10'], interval '2 days'); +---- +{[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01], [10@2000-01-10 00:00:00+01]} + +query I +SELECT tfloatSeqSetGaps([tfloat '1@2000-01-01', tfloat '2@2000-01-02', tfloat '10@2000-01-03'], interval '5 days', 5.0); +---- +{[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01], [10@2000-01-03 00:00:00+01]} + +query I +SELECT tfloatSeqSetGaps([tfloat '1@2000-01-01', tfloat '2@2000-01-02', tfloat '3@2000-01-03'], interval '5 days', 5.0); +---- +{[1@2000-01-01 00:00:00+01, 3@2000-01-03 00:00:00+01]} + +# From MF-JSON / HexWKB parsers (generated base-type name family). Strings are the +# MEOS encodings of the corresponding literals (Europe/Brussels session tz). +query I +SELECT tfloatFromMFJSON('{"type":"MovingFloat","values":[1.5,2.5],"datetimes":["2000-01-01T00:00:00+01","2000-01-02T00:00:00+01"],"lower_inc":true,"upper_inc":true,"interpolation":"Linear"}') = tfloat '[1.5@2000-01-01, 2.5@2000-01-02]'; +---- +true + +query I +SELECT tfloatFromHexWKB('0121000E0200000003000000000000F83F005C6C29FFFFFFFF000000000000044000BC434713000000') = tfloat '[1.5@2000-01-01, 2.5@2000-01-02]'; +---- +true + +# asHexWKB output (base hex-WKB) — generated inherited Temporal surface. Round-trips. +query I +SELECT tfloatFromHexWKB(asHexWKB(tfloat '[1.5@2000-01-01, 2.5@2000-01-02]')) = tfloat '[1.5@2000-01-01, 2.5@2000-01-02]'; +---- +true diff --git a/test/sql/tgeompoint.test b/test/sql/tgeompoint.test index d0ae0f99..3134aa2d 100644 --- a/test/sql/tgeompoint.test +++ b/test/sql/tgeompoint.test @@ -698,9 +698,9 @@ SELECT tContains(geometry 'Point(1 1)', tgeompoint 'Point(1 1)@2000-01-01'); t@2000-01-01 00:00:00+01 query I -SELECT tContains(geometry 'Point(1 1)', tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03]', true); +SELECT tContains(geometry 'Point(1 1)', tgeompoint '[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03]'); ---- -{[t@2000-01-01 00:00:00+01], [t@2000-01-03 00:00:00+01]} +{[t@2000-01-01 00:00:00+01], (f@2000-01-01 00:00:00+01, t@2000-01-03 00:00:00+01]} query I SELECT tDisjoint(geometry 'Point(1 1)', NULL::tgeompoint); @@ -713,7 +713,7 @@ SELECT tDisjoint(geometry 'Point(1 1)', tgeompoint '{[Point(1 1)@2000-01-01, Poi {[f@2000-01-01 00:00:00+01], (t@2000-01-01 00:00:00+01, f@2000-01-03 00:00:00+01], [t@2000-01-04 00:00:00+01, t@2000-01-05 00:00:00+01]} query I -SELECT tDisjoint(tgeompoint '{[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03], [Point(3 3)@2000-01-04, Point(3 3)@2000-01-05]}', tgeompoint 'Point(1 1)@2000-01-01', false); +SELECT tDisjoint(tgeompoint '{[Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03], [Point(3 3)@2000-01-04, Point(3 3)@2000-01-05]}', tgeompoint 'Point(1 1)@2000-01-01'); ---- f@2000-01-01 00:00:00+01 @@ -723,7 +723,7 @@ SELECT tIntersects(tgeompoint '{Point(1 1 1)@2000-01-01, Point(2 2 2)@2000-01-02 {f@2000-01-01 00:00:00+01, t@2000-01-02 00:00:00+01, f@2000-01-03 00:00:00+01} query I -SELECT tIntersects(tgeompoint 'Point(1 1)@2000-01-01', geometry 'Point(1 1)', true); +SELECT tIntersects(tgeompoint 'Point(1 1)@2000-01-01', geometry 'Point(1 1)'); ---- t@2000-01-01 00:00:00+01 @@ -733,9 +733,9 @@ SELECT tTouches(geometry 'Point(1 1)', tgeompoint '{[Point(1 1)@2000-01-01, Poin {[f@2000-01-01 00:00:00+01, f@2000-01-03 00:00:00+01], [f@2000-01-04 00:00:00+01, f@2000-01-05 00:00:00+01]} query I -SELECT tTouches(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03}', geometry 'Point(1 1)', true); +SELECT tTouches(tgeompoint '{Point(1 1)@2000-01-01, Point(2 2)@2000-01-02, Point(1 1)@2000-01-03}', geometry 'Point(1 1)'); ---- -NULL +{f@2000-01-01 00:00:00+01, f@2000-01-02 00:00:00+01, f@2000-01-03 00:00:00+01} query I SELECT tDwithin(geometry 'Point empty', tgeompoint 'Point(1 1)@2000-01-01', 2); diff --git a/test/sql/tint.test b/test/sql/tint.test index 1d5b5678..1ee7070f 100644 --- a/test/sql/tint.test +++ b/test/sql/tint.test @@ -411,7 +411,7 @@ select tempDump(tint '[1@2001-01-01, 2@2001-01-02, 1@2001-01-03]'); [{'value': 1, 'time': '{[2001-01-01 00:00:00+01, 2001-01-02 00:00:00+01), [2001-01-03 00:00:00+01, 2001-01-03 00:00:00+01]}'}, {'value': 2, 'time': '{[2001-01-02 00:00:00+01, 2001-01-03 00:00:00+01)}'}] query I -SELECT atValues(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', intspan '[1,3]'); +SELECT atSpan(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', intspan '[1,3]'); ---- {[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01, 1@2000-01-03 00:00:00+01], [3@2000-01-04 00:00:00+01, 3@2000-01-05 00:00:00+01]} @@ -510,23 +510,35 @@ SELECT atValues(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intset '{1}') ---- {[1@2000-01-01 00:00:00+01, 1@2000-01-02 00:00:00+01), [1@2000-01-03 00:00:00+01]} -query I +query I SELECT minusValues(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intset '{1}'); ---- {[2@2000-01-02 00:00:00+01, 2@2000-01-03 00:00:00+01)} -query I -SELECT atValues(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', intspan '[1,3]'); +# atValues / minusValues on tbigint with a bigintset — the overload the generated catalog +# surface adds (the retired hand regs covered only tint/tfloat/ttext). +query I +SELECT atValues(tbigint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', bigintset '{1}'); +---- +{[1@2000-01-01 00:00:00+01, 1@2000-01-02 00:00:00+01), [1@2000-01-03 00:00:00+01]} + +query I +SELECT minusValues(tbigint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', bigintset '{1}'); +---- +{[2@2000-01-02 00:00:00+01, 2@2000-01-03 00:00:00+01)} + +query I +SELECT atSpan(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', intspan '[1,3]'); ---- {[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01, 1@2000-01-03 00:00:00+01], [3@2000-01-04 00:00:00+01, 3@2000-01-05 00:00:00+01]} query I -SELECT minusValues(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intspan '[1,3]'); +SELECT minusSpan(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intspan '[1,3]'); ---- NULL query I -SELECT minusValues(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intspanset '{[1,3]}'); +SELECT minusSpanset(tint '[1@2000-01-01, 2@2000-01-02, 1@2000-01-03]', intspanset '{[1,3]}'); ---- NULL @@ -545,12 +557,24 @@ SELECT atTBox(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3 ---- {[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01]} -query I +query I SELECT minusTBox(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', tbox 'TBOXINT XT([1,2],[2000-01-01,2000-01-02])'); ---- {(2@2000-01-02 00:00:00+01, 1@2000-01-03 00:00:00+01], [3@2000-01-04 00:00:00+01, 3@2000-01-05 00:00:00+01]} -query I +# atTbox / minusTbox on tbigint (with a bigint tbox) — the overload the generated catalog +# surface adds (the retired hand regs covered only tint/tfloat). +query I +SELECT atTbox(tbigint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', tbox 'TBOXBIGINT XT([1,2],[2000-01-01,2000-01-02])'); +---- +{[1@2000-01-01 00:00:00+01, 2@2000-01-02 00:00:00+01]} + +query I +SELECT minusTbox(tbigint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}', tbox 'TBOXBIGINT XT([1,2],[2000-01-01,2000-01-02])'); +---- +{(2@2000-01-02 00:00:00+01, 1@2000-01-03 00:00:00+01], [3@2000-01-04 00:00:00+01, 3@2000-01-05 00:00:00+01]} + +query I SELECT beforeTimestamp(tint '1@2000-01-02', timestamptz '2000-01-02'); ---- NULL @@ -575,7 +599,41 @@ SELECT tint '{1@2000-01-01, 2@2000-01-02, 1@2000-01-03}' <= tint '1@2000-01-01'; ---- false -query I +query I SELECT duration(tint '{[1@2000-01-01, 2@2000-01-02, 1@2000-01-03],[3@2000-01-04, 3@2000-01-05]}'); ---- 3 days + +# From MF-JSON / HexWKB parsers (base-type name family, generated). The strings are +# the MEOS encodings of the corresponding literals (Europe/Brussels session tz). +query I +SELECT tintFromMFJSON('{"type":"MovingInteger","values":[1],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') = tint '1@2000-01-01'; +---- +true + +query I +SELECT tintFromHexWKB('0123000101000000005C6C29FFFFFFFF') = tint '1@2000-01-01'; +---- +true + +query I +SELECT tbigintFromMFJSON('{"type":"MovingBigInteger","values":[42],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') = tbigint '42@2000-01-01'; +---- +true + +query I +SELECT tbigintFromHexWKB('014300012A00000000000000005C6C29FFFFFFFF') = tbigint '42@2000-01-01'; +---- +true + +# asHexWKB output (base hex-WKB) — the inherited Temporal output surface generated over +# every temporal subtype (was missing for the base temporals). Round-trips through FromHexWKB. +query I +SELECT tintFromHexWKB(asHexWKB(tint '1@2000-01-01')) = tint '1@2000-01-01'; +---- +true + +query I +SELECT tbigintFromHexWKB(asHexWKB(tbigint '42@2000-01-01')) = tbigint '42@2000-01-01'; +---- +true diff --git a/test/sql/tquadbin.test b/test/sql/tquadbin.test new file mode 100644 index 00000000..1ef18faa --- /dev/null +++ b/test/sql/tquadbin.test @@ -0,0 +1,35 @@ +require mobilityduck + +# ── static cell round-trip ────────────────────────────────────────────────── +query I +SELECT quadbinTileToCell(1, 0, 1); +---- +5194902170171867135 + +query I +SELECT quadbinGetResolution(quadbinTileToCell(2, 1, 2)); +---- +2 + +query I +SELECT quadbinIsValidCell(quadbinTileToCell(5, 3, 3)); +---- +true + +query III +SELECT quadbinCellToTileX(quadbinTileToCell(2, 1, 2)), + quadbinCellToTileY(quadbinTileToCell(2, 1, 2)), + quadbinCellToTileZ(quadbinTileToCell(2, 1, 2)); +---- +2 1 2 + +# ── tquadbin instant constructor + accessor ───────────────────────────────── +query I +SELECT startValue(tquadbin(quadbinTileToCell(1,0,1), TIMESTAMPTZ '2024-01-01')); +---- +5194902170171867135 + +query I +SELECT endValue(tquadbin(quadbinTileToCell(2,1,2), TIMESTAMPTZ '2024-06-01')); +---- +5199124294822526975 diff --git a/test/sql/ttext.test b/test/sql/ttext.test index 79745123..fb9e5023 100644 --- a/test/sql/ttext.test +++ b/test/sql/ttext.test @@ -135,7 +135,25 @@ SELECT duration(ttext '{[AAA@2000-01-01, BBB@2000-01-02, AAA@2000-01-03],[CCC@20 ---- 4 days -query I +query I SELECT duration(ttext '{[AAA@2000-01-01, BBB@2000-01-02, AAA@2000-01-03],[CCC@2000-01-04, CCC@2000-01-05]}'); ---- 3 days + +# From MF-JSON / HexWKB parsers (generated base-type name family). Strings are the +# MEOS encodings of the corresponding literals (Europe/Brussels session tz). +query I +SELECT ttextFromMFJSON('{"type":"MovingText","values":["abc"],"datetimes":["2000-01-01T00:00:00+01"],"interpolation":"None"}') = ttext 'abc@2000-01-01'; +---- +true + +query I +SELECT ttextFromHexWKB('012900010300000000000000616263005C6C29FFFFFFFF') = ttext 'abc@2000-01-01'; +---- +true + +# asHexWKB output (base hex-WKB) — generated inherited Temporal surface. Round-trips. +query I +SELECT ttextFromHexWKB(asHexWKB(ttext 'abc@2000-01-01')) = ttext 'abc@2000-01-01'; +---- +true diff --git a/tools/catalog/README.md b/tools/catalog/README.md new file mode 100644 index 00000000..89d1ecdf --- /dev/null +++ b/tools/catalog/README.md @@ -0,0 +1,24 @@ +# MEOS catalog + +`meos-idl.json` is the MEOS-API catalog that `tools/codegen_duck_udfs.py` reads to +generate `src/generated/*.cpp`. It is **not** vendored in this repository — it is +derived from MobilityDB so it can never drift from the libmeos the extension is +built against. + +- **In CI**, `.github/workflows/generate.yml` derives it via the shared + `MobilityDB/MEOS-API/.github/actions/provision-meos` action, using the MobilityDB + commit pinned by the vcpkg MEOS port (`vcpkg_ports/meos/portfile.cmake` `REF`), then + regenerates `src/generated/` and fails if the committed output has drifted. + +- **Locally**, derive it from the same commit with the MEOS-API generator: + + ```sh + MDB_SRC_ROOT= \ + python3 /run.py /meos/include + cp /output/meos-idl.json tools/catalog/meos-idl.json + python3 tools/codegen_duck_udfs.py \ + tools/catalog/meos-idl.json src/generated/generated_temporal_udfs.cpp + ``` + +The committed `src/generated/*.cpp` is the buildable snapshot the distribution +pipeline compiles; the `generate` workflow keeps it equal to a fresh derivation. diff --git a/tools/codegen_duck_udfs.py b/tools/codegen_duck_udfs.py new file mode 100644 index 00000000..52ec6880 --- /dev/null +++ b/tools/codegen_duck_udfs.py @@ -0,0 +1,3248 @@ +#!/usr/bin/env python3 +""" +MobilityDuck UDF generator — projects the MEOS-API catalog (meos-idl.json) into +DuckDB C++ scalar-UDF registrations. MIRRORS the MobilitySpark generator +(tools/codegen_spark_udfs.py, which mirrors JMEOS FunctionsGenerator) — same +catalog, same classify()/supported() selection logic — but emits DuckDB C++ +instead of Java, and marshals via the in-process BLOB path (BlobToTemporal / +TemporalToBlob) instead of hex-WKB, since MobilityDuck links MEOS in-process. + +North star: bindings are GENERATED from the catalog; this replaces hand-written +UDFs (generate-then-retire). POC scope = scalar functions with the tractable +arg/return shapes; table functions, casts, aggregates, and full per-type +polymorphism expansion are the documented next increments. + +Usage: python3 tools/codegen_duck_udfs.py [out.cpp] +""" +import json, sys, re, os +from collections import defaultdict, Counter + +def norm(c): + # Strip the `const` and `struct` keywords (the 14l catalog renders canonical + # types as e.g. `const struct Temporal *`); word-boundary so type names that + # merely contain the substring are untouched. + return re.sub(r'\s+', ' ', re.sub(r'\b(const|struct)\b', '', c or '')).strip() + +def base(canon): + t = norm(canon) + if "(*" in t or "()" in t or t.endswith("**"): + return "__INTERNAL__" + return t.replace("*", "").strip() + +# ---- DuckDB type + marshalling maps (the Duck-specific part) ---- +# Pointer args/returns that travel as the DuckDB BLOB-backed custom type and +# marshal in-process via malloc+memcpy (BlobToTemporal) / Value::BLOB(TemporalToBlob). +# %s = the per-row input string_t (arg) / the MEOS pointer (ret). +PTR_IN = { # MEOS base type -> (DuckDB arg LogicalType, "C++ expr producing the MEOS ptr from string_t `%s`") + "Temporal": ("MD_TEMPORAL", "BlobToTemporal(%s)"), + "TInstant": ("MD_TEMPORAL", "BlobToTemporal(%s)"), + "TSequence": ("MD_TEMPORAL", "BlobToTemporal(%s)"), + "TSequenceSet": ("MD_TEMPORAL", "BlobToTemporal(%s)"), + "Set": ("LogicalType::BLOB", "BlobToSet(%s)"), + "Span": ("LogicalType::BLOB", "BlobToSpan(%s)"), + "SpanSet": ("LogicalType::BLOB", "BlobToSpanSet(%s)"), + "STBox": ("LogicalType::BLOB", "BlobToStbox(%s)"), + "TBox": ("LogicalType::BLOB", "BlobToTbox(%s)"), + "Cbuffer": ("CbufferTypes::cbuffer()", "BlobToCbuffer(%s)"), +} +PTR_RET = { # MEOS base type -> (DuckDB ret LogicalType, "C++ expr producing string_t from MEOS ptr `%s` in `result`") + "Temporal": ("MD_TEMPORAL", "TemporalToBlob(result, %s)"), + "TInstant": ("MD_TEMPORAL", "TemporalToBlob(result, %s)"), + "TSequence": ("MD_TEMPORAL", "TemporalToBlob(result, %s)"), + "TSequenceSet": ("MD_TEMPORAL", "TemporalToBlob(result, %s)"), + "Set": ("LogicalType::BLOB", "SetToBlob(result, %s)"), + "Span": ("LogicalType::BLOB", "SpanToBlob(result, %s)"), + "SpanSet": ("LogicalType::BLOB", "SpanSetToBlob(result, %s)"), + "STBox": ("LogicalType::BLOB", "StboxToBlob(result, %s)"), + "TBox": ("LogicalType::BLOB", "TboxToBlob(result, %s)"), + "Cbuffer": ("CbufferTypes::cbuffer()", "CbufferToBlob(result, %s)"), +} +# The temporal-family pointer returns that marshal as one DuckDB temporal handle. A MEOS +# accessor/cast can return a concrete subtype pointer (TInstant */TSequence */TSequenceSet * +# — e.g. startInstant, tintSeqSet) but the wire representation and the SQL result type are the +# base temporal type of the input (the subtype is erased in SQL), so they emit exactly like a +# `Temporal *` return; the C++ subtype pointer is upcast to `Temporal *` before marshalling. +TEMPORAL_PTR_RET = {k for k, v in PTR_RET.items() if v[0] == "MD_TEMPORAL"} +# Base-value pointer returns: a family's BASE value (Cbuffer today; Npoint/Pose/... follow), +# neither a temporal handle nor a container. A Temporal Accessor such as startValue/endValue +# returns the base value via the per-type MEOS symbol (tcbuffer_start_value -> Cbuffer *) and is +# marshalled by the base-value blob marshaller ({Base}ToBlobN). Derived from PTR_RET so adding a +# base value there (with its type + {Base}ToBlobN marshaller) auto-enables its accessors. +_CONTAINER_PTR_RET = {"Set", "Span", "SpanSet", "STBox", "TBox"} +BASEVAL_PTR_RET = set(PTR_RET) - TEMPORAL_PTR_RET - _CONTAINER_PTR_RET +# Base-value pointer ARGS: the mirror of BASEVAL_PTR_RET on the input side — a family's BASE +# value passed by pointer (Cbuffer today; Pose/Npoint/... when their PTR_IN entry + DuckDB type +# land), as opposed to the temporal handles and the collection/box pointers (owned by other +# shapes). This is the 2nd operand of the uniform (Temporal, T) -> Temporal range-point +# restriction (atValue/minusValue) for the pointer-valued base families; marshalled via PTR_IN +# and freed after the MEOS call. +_CONTAINER_PTR_IN = {"Temporal", "TInstant", "TSequence", "TSequenceSet", + "Set", "Span", "SpanSet", "STBox", "TBox"} +BASEVAL_PTR_IN = set(PTR_IN) - _CONTAINER_PTR_IN +# Scalar (by-value) args/returns -> (DuckDB LogicalType, C++ scalar type) +SCALAR = { + "int": ("LogicalType::INTEGER", "int32_t"), + "int32": ("LogicalType::INTEGER", "int32_t"), + "int32_t": ("LogicalType::INTEGER", "int32_t"), + "int64": ("LogicalType::BIGINT", "int64_t"), + "int64_t": ("LogicalType::BIGINT", "int64_t"), + "double": ("LogicalType::DOUBLE", "double"), + "float8": ("LogicalType::DOUBLE", "double"), + "bool": ("LogicalType::BOOLEAN", "bool"), + "TimestampTz": ("LogicalType::TIMESTAMP_TZ", "timestamp_tz_t"), + "DateADT": ("LogicalType::DATE", "date_t"), +} +OUTPRIM = {"int *": "LogicalType::INTEGER", "int64_t *": "LogicalType::BIGINT", + "double *": "LogicalType::DOUBLE", "bool *": "LogicalType::BOOLEAN"} + +def classify(f): + """Mirror of the Spark generator: split params into (in_params, out_canon|None). + Drops a trailing size_t* buffer-length out-param; on bool/void return with a + single trailing writable pointer, that pointer is the out-param.""" + params = list(f["params"]) + 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("*") + others = [p for p in params[:-1] if "const" not in p["canonical"] + and norm(p["canonical"]).endswith("*") + and (norm(p["canonical"]) in OUTPRIM or base(p["canonical"]) in PTR_RET)] + if writable and not others and (lastn in OUTPRIM or base(lastc) in PTR_RET): + return params[:-1], lastc + return params, None + +def arg_type(canon): + """(duck_type, marshal_expr_or_None) for an input param, else None if unmappable.""" + nc = norm(canon); b = base(canon) + if b in PTR_IN and nc.endswith("*"): + return PTR_IN[b] + if b in SCALAR and "*" not in nc: + dt, _ = SCALAR[b] + return (dt, None) # by-value scalar + if b == "char" and nc.count("*") == 1: + return ("LogicalType::VARCHAR", None) + if b == "text" and nc.endswith("*"): + return ("LogicalType::VARCHAR", None) + return None + +def ret_type(f, out_canon): + """(duck_ret_type, kind) where kind in {ptr,scalar,outprim,outptr}. None if unmappable.""" + if out_canon is not None: + n = norm(out_canon) + if n in OUTPRIM: return (OUTPRIM[n], "outprim") + if base(out_canon) in PTR_RET: return (PTR_RET[base(out_canon)][0], "outptr") + return None + rc = f["returnType"]["canonical"]; nc = norm(rc); b = base(rc) + if b in PTR_RET and nc.endswith("*"): return (PTR_RET[b][0], "ptr") + if b in SCALAR and "*" not in nc: return (SCALAR[b][0], "scalar") + if b == "GSERIALIZED" and nc.endswith("*"): # owned geometry -> DuckDB GEOMETRY (geo marshaller) + return ("GeoTypes::GEOMETRY()", "geo") + if b == "Interval" and nc.endswith("*"): # owned ptr -> by-value interval_t (TakeInterval) + return ("LogicalType::INTERVAL", "scalar") + if b == "text" and nc.endswith("*"): # owned text* varlena -> VARCHAR (TakeText) + return ("LogicalType::VARCHAR", "scalar") + if b == "char" and nc.endswith("*"): # owned C-string -> VARCHAR (TakeCString) + return ("LogicalType::VARCHAR", "scalar") + return None + +# The temporal type families the BINDING registers as DuckDB types (SoT = the binding's +# RegisterType calls in src/). A generated UDF is in scope only when EVERY type family its +# name references is registered; a name that references an as-yet-unregistered family +# (e.g. tcbuffer_to_tfloat, tbigint_to_th3index, tgeompoint_to_tnpoint, ttext_to_tjsonb) +# would register under the wrong DuckDB type / be uncallable, and would drag an unused MEOS +# module — so it is OUT OF SCOPE until that family's fast-follow wave registers the type, +# at which point moving the token into REGISTERED_FAMILIES re-includes it automatically. +# CODEGEN-REGULAR-EXCEPTION: registered-type-scope CLASSIFICATION — a positive allowlist +# (= the binding's RegisterType set), reason-audited in main() as "unregistered-family"; +# NOT a skip-to-pass family filter. When a family is registered, add its token here. +REGISTERED_FAMILIES = { + "temporal", "tnumber", "tint", "tbigint", "tfloat", "tbool", "ttext", + "tgeompoint", "tgeogpoint", "tgeometry", "tgeography", "tgeo", "tspatial", "tquadbin", + "tcbuffer", "cbuffer", +} +# Every temporal family token the catalog function names use; those NOT in REGISTERED_FAMILIES +# are the fast-follow families whose DuckDB type the binding does not register yet. +KNOWN_FAMILIES = REGISTERED_FAMILIES | { + "th3index", "tnpoint", "tpose", "trgeometry", "trgeo", "tpcpoint", "tpcpatch", + "tjsonb", "npoint", "nsegment", "pose", "pcpoint", "pcpatch", "jsonb", "h3index", +} +def unregistered_family_ref(name): + """The first unregistered family token the name references, else None (in scope).""" + bad = (set(name.split("_")) & KNOWN_FAMILIES) - REGISTERED_FAMILIES + return sorted(bad)[0] if bad else None + +# Param-name tokens that denote a SPECIFIC temporal family (vs the generic `temp`/`temp1`/ +# `inst`/... used for same-type operands). Read straight from the catalog `params[].name`. +_PARAM_FAMILY_TOK = re.compile( + r'^(tpoint|tfloat|tgeo|tnpoint|tcbuffer|tnumber|tint|tbigint|tbool|ttext' + r'|tgeompoint|tgeogpoint|tgeometry|tgeography)') +def hetero_temporal_args(f): + """True when a function's operands are ALL generic `Temporal *` in the C signature but + the catalog param NAMES denote two or more DISTINCT temporal families (e.g. + tcbuffer_make(tpoint, tfloat) -> tcbuffer). Such a function cannot be typed per-argument + from the current catalog — the C args are polymorphic and there are no per-overload + sqlSignatures — so the single-family specialization would register WRONG argument types. + Excluded until the catalog carries per-arg SQL types (Track B); reachable meanwhile via + the text-I/O cast the binding registers by hand.""" + tps = [p for p in (f.get("params") or []) + if base(p.get("canonical", "")) == "Temporal" and norm(p.get("canonical", "")).endswith("*")] + if len(tps) < 2: + return False + fams = set() + for p in tps: + m = _PARAM_FAMILY_TOK.match(p.get("name") or "") + if m: + fams.add(m.group(1)) + return len(fams) >= 2 + +def supported(f): + """Reason string if NOT emittable (mirrors Spark's supported()), else None.""" + name = f["name"] + if name.startswith("meos_internal") or (f.get("group") or "").startswith("meos_internal"): + return "internal" + if not f.get("sqlfn"): + return "no-sqlfn" # not user-facing SQL surface + # type I/O machinery (in/out/send/recv) — these are the VARCHAR/binary CASTS, registered + # via RegisterCastFunctions, NOT standalone scalar UDFs. The real text fns are asText/interp. + if re.search(r'_(out|in|send|recv)$', f.get("sqlfn") or ""): + return "io-cast" + # registered-type scope: a UDF touching a family whose DuckDB type is not registered yet + # is out of scope until its fast-follow wave (see REGISTERED_FAMILIES above). + u = unregistered_family_ref(name) + if u is not None: + return "unregistered-family:" + u + # heterogeneous generic-Temporal operands the catalog can't type per-arg yet (Track B) + if hetero_temporal_args(f): + return "hetero-temporal-args" + in_params, out = classify(f) + if ret_type(f, out) is None: + return "ret:" + norm(f["returnType"]["canonical"]) + for p in in_params: + if arg_type(p["canonical"]) is None: + return "arg:" + norm(p["canonical"]) + return None + +def family(f): + """Type-family bucket for file organization (compile-flag gating). Mirrors the + by-family convention; uses the @ingroup group if present, else the source file.""" + g = f.get("group") or "" + if g.startswith("meos_"): return g[len("meos_"):] + return (f.get("file") or "meos").replace(".h", "") + +# ---------------- Full executor-body emit (COMPILABLE POC subset) ---------------- +# Subset guaranteed to compile against the hand binding's helpers: +# - exactly ONE input param, +# - arg is a generic `const Temporal *` (marshalled via BlobToTemporal), +# - return is Temporal* (TemporalToBlob) or a by-value scalar (int/int64/double/bool). +# Registered for EVERY temporal DuckDB type via TemporalTypes::AllTypes() — the same +# polymorphism the hand binding uses. (Spans/sets/boxes/binary/out-params = next increment.) +SCALAR_RET_CPP = {"int": ("int32_t", "LogicalType::INTEGER"), + "int32_t": ("int32_t", "LogicalType::INTEGER"), + "int64_t": ("int64_t", "LogicalType::BIGINT"), + "double": ("double", "LogicalType::DOUBLE"), + "bool": ("bool", "LogicalType::BOOLEAN")} +# By-value scalar returns the TEMPORAL detectors accept: the identity-marshalled ones +# (SCALAR_RET_CPP) plus the time types that need a conversion on return (TimestampTz via +# TakeTimestamp, DateADT via FromMeosDate — handled in scalar_emit3/scalar_ret_duck). +BYVAL_RET = set(SCALAR_RET_CPP) | {"TimestampTz", "DateADT"} + +def is_pred_int(f): + """ever_*/always_* return MEOS `int` but are semantically BOOLEAN (everEq answers + 'is it EVER equal?' = a single bool, vs teq = a pointwise tbool). The spatial + ever/always relationships (catalog group `*_rel_ever`/`*_rel_always`: aDisjoint, + eContains, eCovers, eIntersects, eTouches, eDwithin, ...) are the same shape — a + scalar `int` 0/1 that is a SQL BOOLEAN — but their names are the bare a*/e* form, so + key on the catalog group too (mirrors the increment-18 geo-comparison BOOLEAN rule). + The `*Pairs` array variants return `int *` (a SETOF) and are excluded by the no-`*` + guard.""" + rc = f["returnType"]["canonical"] + if base(rc) not in ("int", "int32_t") or "*" in norm(rc): + return False + return (re.match(r'(ever|always)_', f["name"]) is not None + or re.search(r'_rel_(ever|always)$', f.get("group") or "") is not None) + +def scalar_ret_duck(f): + """DuckDB registration return type for a by-value scalar return.""" + if is_pred_int(f): + return "LogicalType::BOOLEAN" + rb = base(f["returnType"]["canonical"]) + if rb == "Interval": return "LogicalType::INTERVAL" + if rb == "TimestampTz": return "LogicalType::TIMESTAMP_TZ" + if rb == "DateADT": return "LogicalType::DATE" + if rb in ("text", "char"): return "LogicalType::VARCHAR" + return SCALAR_RET_CPP[rb][1] + +def scalar_emit3(f): + """(call_var_ctype, executor_RET, return_expr) — for ever_/always_ the MEOS call + yields int but the UDF returns bool via (r != 0); an owned MEOS Interval* is + converted+freed via TakeInterval (preamble helper).""" + if is_pred_int(f): + return ("int32_t", "bool", "(r != 0)") + rb = base(f["returnType"]["canonical"]) + if rb == "Interval": return ("MeosInterval *", "interval_t", "TakeInterval(r)") + if rb == "TimestampTz": return ("TimestampTz", "timestamp_tz_t", "TakeTimestamp(r)") + if rb == "DateADT": return ("DateADT", "date_t", "FromMeosDate((int32_t) r)") + if rb == "text": return ("text *", "string_t", "TakeText(result, r)") + if rb == "char": # const char* = borrowed/static (no free); char* = owned (free) + if "const" in (f["returnType"]["canonical"] or ""): + return ("const char *", "string_t", "StringVector::AddString(result, r)") + return ("char *", "string_t", "TakeCString(result, r)") + ct = SCALAR_RET_CPP[rb][0] + return (ct, ct, "r") + +# By-value/owned-scalar return marshalling keyed by the MEOS return base type — used by the +# container (set/span) u_scalar branches so they handle time/Interval returns like the +# temporal detectors do. (call_var_ctype, executor_RET, return_expr). +def byval_ret3(e): + if e == "Interval": return ("MeosInterval *", "interval_t", "TakeInterval(r)") + if e == "TimestampTz": return ("TimestampTz", "timestamp_tz_t", "TakeTimestamp(r)") + if e == "DateADT": return ("DateADT", "date_t", "FromMeosDate((int32_t) r)") + if e == "text": return ("text *", "string_t", "TakeText(result, r)") + if e == "char": return ("char *", "string_t", "TakeCString(result, r)") + return (SCALAR_RET_CPP[e][0], SCALAR_RET_CPP[e][0], "r") +def byval_ret_duck(e): + return {"Interval": "LogicalType::INTERVAL", "TimestampTz": "LogicalType::TIMESTAMP_TZ", + "DateADT": "LogicalType::DATE", "text": "LogicalType::VARCHAR"}.get( + e, SCALAR_RET_CPP[e][1] if e in SCALAR_RET_CPP else None) + +# C-name prefix -> the concrete DuckDB temporal type(s) a fn registers for. +# Core binding temporal types are TINT/TFLOAT/TBOOL/TTEXT (TBIGINT/geo = separate +# families, gated elsewhere). "all" = the generic AllTypes() loop. +CORE_TYPES = { + "tint": ["TemporalTypes::tint()"], + "tbigint":["TemporalTypes::tbigint()"], + "tfloat": ["TemporalTypes::tfloat()"], + "tbool": ["TemporalTypes::tbool()"], + "ttext": ["TemporalTypes::ttext()"], + "tnumber":["TemporalTypes::tint()", "TemporalTypes::tfloat()"], +} +# Geo TEMPORAL types are Temporal* blobs (BlobToTemporal works). Accessor class names +# are inconsistent in the hand binding (verified live: TgeompointType/TgeogpointType/ +# TGeometryTypes/TGeographyTypes) — used as-is; canonical type names from meos_catalog.c. +# Functions with GSERIALIZED*/Geo* args or returns auto-EXCLUDE (supported() rejects them), +# so only the Temporal-only geo shapes (tgeo×tgeo comparison) emit here. +GEO_TYPES = { + "tgeompoint": "TgeompointType::tgeompoint()", "tgeogpoint": "TgeogpointType::tgeogpoint()", + "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()", +} +GEO_ALLTYPES = list(GEO_TYPES.values()) +# The TSpatial subtypes = the geo types PLUS the other spatial temporal families +# (tcbuffer first; tnpoint/tpose/trgeometry/th3index/tpcpoint follow). A spatial family +# inherits the abstract `tspatial_*` surface (SRID/setSRID/transform/asText/asEWKT/atStbox) +# and the generic Temporal surface by BEING IN THIS LIST — it is looped alongside the geo +# types by the `tspatial_*` scope and the generic-temporal "all" writer. Distinct from +# GEO_ALLTYPES, which stays geo-only for the `tgeo` supertype (geometry+geography) and the +# geometry-argument spatial relationships. Add a new spatial family here to inherit the surface. +SPATIAL_ALLTYPES = GEO_ALLTYPES + ["CbufferTypes::tcbuffer()"] +def reg_scope(name): + """('all', None) generic | ('types', [accessors]) specific | None = not core family. + Resolves the temporal type from the MobilityDB naming convention: a PREFIX + (temporal_*/tint_*/...) OR a same-type SUFFIX (e.g. tand_tbool_tbool, + distance_tfloat_tfloat, ever_eq_temporal_temporal). Mixed-type suffixes are + skipped (ambiguous).""" + # Bounding-box TOPOLOGICAL ops (same/contains/contained/overlaps/adjacent) have + # TYPE-DEPENDENT bbox semantics, so MobilityDB backs each bbox shape with a distinct + # MEOS function: the generic *_temporal_temporal compares ONLY the time bbox, *_tnumber_ + # tnumber the value+time (tbox), *_tspatial_tspatial the space+time (stbox). The generic + # C signature is `(Temporal *, Temporal *)`, so the plain name-token heuristic below would + # scope *_temporal_temporal to ("all") temporal types — registering the TIME-ONLY op for + # number and spatial types too. Since DuckDB overload resolution is last-registration-wins + # among the alias-BLOB overloads, that generic then SHADOWS the correct value-/space-aware + # backing (proven: ~=/same_bbox/@>/… on tgeompoint × tgeompoint silently compared only time). + # Scope each explicitly to the types whose bbox it actually models: + # • *_temporal_temporal -> tbool, ttext (bbox = tstzspan, purely temporal) + # • *_tnumber_tnumber -> tint, tfloat, tbigint (bbox = tbox; all three are tnumber_type + # per meos_catalog.c:1234, tbigint incl.) + # • *_tspatial_tspatial -> the 4 geo types (handled by the tspatial/tgeo rules below) + _bbox_topo = re.match(r'^(?:same|contains|contained|overlaps|adjacent)_(\w+)$', name) + if _bbox_topo: + base = _bbox_topo.group(1) + if base == "temporal_temporal": + return ("types", CORE_TYPES["tbool"] + CORE_TYPES["ttext"]) + if base == "tnumber_tnumber": + return ("types", CORE_TYPES["tint"] + CORE_TYPES["tfloat"] + CORE_TYPES["tbigint"]) + if name.startswith("temporal_"): + return ("all", None) + for pre, accs in CORE_TYPES.items(): + if name.startswith(pre + "_"): + return ("types", accs) + # geo temporal types: a specific _* prefix, or the generic "tgeo" token + # (ever_eq_tgeo_tgeo) -> all 4 geo types. geometry-coupled variants auto-exclude. + for pre, acc in GEO_TYPES.items(): + if name.startswith(pre + "_"): + return ("types", [acc]) + # the abstract point supertype tpoint_* covers both point subtypes (getX/azimuth/ + # speed/... live under this MEOS name); geometry-coupled variants auto-exclude. + if name.startswith("tpoint_"): + return ("types", [GEO_TYPES["tgeompoint"], GEO_TYPES["tgeogpoint"]]) + # the abstract spatial supertype tspatial_* covers ALL spatial temporal types (the 4 geo + # types + tcbuffer + future spatial families) with type-preserving results (setSRID/ + # transform/transformPipeline preserve the operand type; asText/asEWKT return text); + # geometry-coupled variants auto-exclude. This is the TSpatial inherited surface. + if name.startswith("tspatial_") or re.search(r'_tspatial(?=_|$)', name): + return ("types", SPATIAL_ALLTYPES) + # the geo supertype tgeo covers ONLY geometry+geography (NOT cbuffer/other spatial types). + if re.search(r'_tgeo(?=_|$)', name): + return ("types", GEO_ALLTYPES) + # the circular-buffer temporal family (its own gated spatial type, NOT one of the geo + # types): a tcbuffer_* prefix, or a _tcbuffer token anywhere (ever_eq_tcbuffer_tcbuffer, + # tdwithin_tcbuffer_tcbuffer, contains_tcbuffer_tcbuffer). GSERIALIZED/Datum-coupled + # variants auto-exclude on their unmarshallable arg. + if name.startswith("tcbuffer_") or re.search(r'_tcbuffer(?=_|$)', name): + return ("types", ["CbufferTypes::tcbuffer()"]) + # temporal-type token ANYWHERE in the name (always_eq_tint_int, ever_lt_tfloat_tfloat, + # tdistance_tfloat_tfloat, teq_temporal_temporal). Skip if >1 DISTINCT temporal type + # appears (mixed/ambiguous) — geo tokens (tgeompoint/tgeo/th3index/tnpoint) aren't in + # the set, so geo/extended fns correctly fall through to None (their own gated family). + toks = re.findall(r'_(temporal|tnumber|tint|tbigint|tfloat|tbool|ttext)(?=_|$)', name) + if toks: + if len(set(toks)) > 1: + return None + t1 = toks[0] + if t1 == "temporal": + return ("all", None) + return ("types", CORE_TYPES[t1]) + return None # tbigint_*/tgeompoint_*/etc. belong to their own (gated) family file + +# Output DuckDB type for a TEMPORAL-returning fn (the return-type-from-name lever): +# a `*_to_t` conversion CHANGES type -> the target accessor; otherwise the fn +# PRESERVES its input type -> the arg's accessor (passed in). +TO_TYPE = {"tint": "TemporalTypes::tint()", "tbigint": "TemporalTypes::tbigint()", + "tfloat": "TemporalTypes::tfloat()", + "tbool": "TemporalTypes::tbool()", "ttext": "TemporalTypes::ttext()", + "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()", + "tgeompoint": "TgeompointType::tgeompoint()", "tgeogpoint": "TgeogpointType::tgeogpoint()", + "tcbuffer": "CbufferTypes::tcbuffer()"} +def ret_temporal_type(name, arg_acc, group="", sql_ret=None): + # A single, unambiguous SQL return subtype from the catalog names the output + # temporal type directly (the catalog is the SoT). The name heuristics below are + # the fallback for functions the catalog leaves input-polymorphic (sqlReturnTypeAll), + # where the return preserves the input type via arg_acc. + if sql_ret and sql_ret in TO_TYPE: + return TO_TYPE[sql_ret] + # temporal comparison ops (teq/tne/tlt/tle/tgt/tge_*) return a tbool, NOT the input type + if re.match(r't(eq|ne|lt|le|gt|ge)_', name): + return "TemporalTypes::tbool()" + # temporal spatial relationships (catalog group `*_rel_temp`: tContains/tDisjoint/ + # tIntersects/tTouches/tDwithin) answer a pointwise predicate over time -> a tbool, not + # the operand geo type (mirrors the teq->tbool rule and the *_rel_ever scalar-BOOLEAN one). + if re.search(r'_rel_temp$', group or ""): + return "TemporalTypes::tbool()" + # the temporal distance tDistance(a,b) is always a tfloat — whatever the operands + # (tnumber or tgeo); the generic MEOS `Temporal *` return doesn't carry that, so the + # name carries it (mirrors the teq->tbool rule above). + if re.match(r'tdistance_', name): + return "TemporalTypes::tfloat()" + # `_to_` conversions CHANGE type to the target -> the `_to_` suffix names it + # (geo targets tgeometry/tgeography/tgeompoint/tgeogpoint added alongside the base ones). + m = re.search(r'_to_(tint|tbigint|tfloat|tbool|ttext|tgeometry|tgeography|tgeompoint|tgeogpoint|tcbuffer)$', name) + return TO_TYPE[m.group(1)] if m else arg_acc + +# The concrete DuckDB accessors the generic temporal track can emit, keyed by the catalog +# SQL type name: the 5 core types (TemporalTypes::AllTypes()) plus the 4 geo types (the +# second emit loop). Ordered so the generated registrations come out canonically (core +# order, then geo). Accessor strings reuse GEO_TYPES / TO_TYPE verbatim. +SIG_TEMPORAL_ACC = { + "tint": "TemporalTypes::tint()", "tbigint": "TemporalTypes::tbigint()", + "tbool": "TemporalTypes::tbool()", "tfloat": "TemporalTypes::tfloat()", + "ttext": "TemporalTypes::ttext()", + "tgeompoint": "TgeompointType::tgeompoint()", "tgeogpoint": "TgeogpointType::tgeogpoint()", + "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()", + "tcbuffer": "CbufferTypes::tcbuffer()", +} +def sig_declared_accs(f): + """The exact temporal-operand types this GENERIC (`Temporal *`) function is CREATE + FUNCTION'd for, read from the catalog's per-overload `sqlSignatures` (the SoT) — so the + generic AllTypes()+geo blanket registration is replaced by the catalog-declared type set + (minInstant/maxInstant land on the four ordered types, not all nine; tintInst on tint + alone). The mechanical replacement for the name/return heuristics on generic functions. + Returns the accessor list in canonical order, or None when the catalog carries no + signature for the function (keep the generic loop as the fallback).""" + sigs = f.get("sqlSignatures") + if not sigs: + return None + have = {a for s in sigs for a in s["args"] if a in SIG_TEMPORAL_ACC} + return [SIG_TEMPORAL_ACC[t] for t in SIG_TEMPORAL_ACC if t in have] or None + +# ---------------- SET family (additive; the temporal path is left untouched) ---------------- +# Self-contained Blob<->Set marshalling reuses the hand binding's exact method +# (malloc+memcpy in; set_mem_size out). Per-element accessors mirror CORE_TYPES. +SET_TYPES = { + "intset": "SetTypes::intset()", "bigintset": "SetTypes::bigintset()", + "floatset": "SetTypes::floatset()", "textset": "SetTypes::textset()", + "dateset": "SetTypes::dateset()", "tstzset": "SetTypes::tstzset()", +} +def set_reg_scope(name): + """('all',None) for generic set_* | ('types',[acc]) for set_* | None.""" + if name.startswith("set_"): + return ("all", None) + for pre, acc in SET_TYPES.items(): + if name.startswith(pre + "_") or name == pre: + return ("types", [acc]) + return None +def ret_set_type(name, arg_acc): + # `*_to_` conversion CHANGES type -> target; else preserve the arg's set type. + m = re.search(r'_to_(intset|bigintset|floatset|textset|dateset|tstzset)$', name) + return SET_TYPES[m.group(1)] if m else arg_acc + +# SQL set-type name -> the CORE Duck accessor. Extended sets (geomset/geogset/ +# cbufferset/npointset/poseset/...) are absent -> a scalar-param overload on them +# registers nothing here (they are gated to their own family files). +SET_SQL_TO_ACC = dict(SET_TYPES) + +def set_scalar_param_sigs(f): + """For a 2-arg (Set, scalar)->Set function, decide from the catalog sqlSignatures + whether arg2 is a fixed PARAM (precision/SRID) rather than a set ELEMENT, and if so + return the [(set accessor, ret accessor)] over the catalog-declared set types. + + The mechanical tell: a scalar param keeps the SAME arg2 SQL type across overloads + whose set arg1 differs (round: (floatset,integer)+(geomset,integer); setSRID/ + transform: (geomset,integer)+(geogset,integer)), whereas a genuine element-add has + arg2 co-vary with the set base (setUnion: (geomset,geometry)+(cbufferset,cbuffer)). + So the set type must come from the signature (floatset), NOT be inferred from the + element scalar (which wrongly yields intset). Returns the (possibly empty) core-type + list when arg2 is a param; None when it is an element (keep the element path).""" + sigs = f.get("sqlSignatures") + two = [s for s in (sigs or []) if len(s["args"]) == 2] + if len(two) < 2: + return None + by_arg2 = defaultdict(set) + for s in two: + by_arg2[s["args"][1]].add(s["args"][0]) + if not any(len(sets) >= 2 for sets in by_arg2.values()): + return None # arg2 co-varies -> element-add + out = [] + for s in two: + acc = SET_SQL_TO_ACC.get(s["args"][0]) + if acc: + defs = s.get("argDefaults") or [None] * len(s["args"]) + out.append((acc, SET_SQL_TO_ACC.get(s["ret"], acc), defs[1])) + return out # may be [] (only extended sets) + +def sql_default_to_cpp(val): + """A SQL DEFAULT literal -> the C++ literal to substitute for the omitted argument. + NULL -> nullptr, TRUE/FALSE -> true/false, a numeric literal (0/15/0.0) verbatim.""" + u = val.strip().upper() + return {"NULL": "nullptr", "TRUE": "true", "FALSE": "false"}.get(u, val.strip()) + +def trailing_arg_default(f): + """The SQL default of the LAST argument if the catalog declares one uniformly across + overloads (round -> '0', degrees -> 'FALSE'), else None. This is the value to substitute + when emitting the shorter overload of a SQL-optional trailing argument.""" + defs = {s["argDefaults"][-1] for s in (f.get("sqlSignatures") or []) if s.get("argDefaults")} + return next(iter(defs)) if len(defs) == 1 and None not in defs else None + +def emit_defaulted_unary(name, blobto, toblob, ctype, dval): + """The shorter (X)->X overload of an (X, scalar-param DEFAULT)->X blob-container function + (set/span/spanset): a UnaryExecutor body calling the MEOS fn with the default substituted.""" + return (f"static void Gen_{name}_d(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::Execute(args.data[0], result, args.size(),\n" + f" [&](string_t a) {{\n" + f" {ctype} *s = {blobto}(a);\n {ctype} *r = {name}(s, {dval});\n free(s);\n" + f" return {toblob}(result, r);\n }});\n}}\n") + +def emit_defaulted_unary_temporal(name, subcast, dval): + """The shorter (temporal)->temporal overload — NULL-safe like emit_body_binary's temporal + kind (MEOS NULL -> SQL NULL via TemporalToBlobN), with the SQL default substituted.""" + return (f"static void Gen_{name}_d(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" Temporal *r = {subcast}{name}(t, {dval});\n free(t);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n" + f" }});\n}}\n") + +def emit_defaulted_unary_temporal_scalar(f, dval): + """The shorter (Temporal)->scalar overload of a (Temporal, scalar-param DEFAULT)->scalar + function (duration(temporal[,boolean]), asText/asEWKT(tspatial[,int])): a UnaryExecutor + calling the MEOS fn with the trailing default substituted, marshalling the by-value/owned + scalar return exactly like emit_body's scalar branch (scalar_emit3).""" + name = f["name"] + cct, rett, rexpr = scalar_emit3(f) + return (f"static void Gen_{name}_d(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::Execute(args.data[0], result, args.size(),\n" + f" [&](string_t in) {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {cct} r = {name}(t, {dval});\n free(t);\n" + f" return {rexpr};\n" + f" }});\n}}\n") + +# Element scalar type -> the Set type it implies (for contains/contained/left/... +# predicates the set type is picked by the element, not the name). Only the +# already-marshalled scalars (text/date deferred — need new marshalling). +ELEM_TO_SET = { + "int": "SetTypes::intset()", "int32_t": "SetTypes::intset()", + "int64_t": "SetTypes::bigintset()", "double": "SetTypes::floatset()", + "TimestampTz": "SetTypes::tstzset()", "DateADT": "SetTypes::dateset()", + "text": "SetTypes::textset()", +} +def selem(p): + """The set-element key for a predicate scalar arg, or None. By-value scalars + (int/double/date/tstz) OR an owned `text *` varlena.""" + b = base(p["canonical"]); ptr = norm(p["canonical"]).endswith("*") + if b == "text" and ptr: return "text" + if b in ELEM_TO_SET and not ptr: return b + return None +def shape_set(f): + """Set-family shapes. Returns (kind, duck_ret) or None. + - element-typed predicates (accessor from the scalar element type, NOT the name): + (Set,scalar)->bool / (scalar,Set)->bool [contains/contained/left/right/over*] + - name-scoped (set_reg_scope): unary (Set)->Set|scalar, binary (Set,Set)->bool|Set""" + if supported(f) is not None: return None + # aggregate transition/final/combine internals are NOT scalar UDFs (separate shape) + if re.search(r'_(transfn|finalfn|combinefn)$', f["name"]): return None + ins, out = classify(f) + if out is not None: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + setp = lambda p: base(p["canonical"]) == "Set" and norm(p["canonical"]).endswith("*") + if len(ins) == 2 and rb == "bool" and "*" not in rn: + e0, e1 = selem(ins[0]), selem(ins[1]) + if setp(ins[0]) and e1: return ("setsc:" + e1, "LogicalType::BOOLEAN") + if setp(ins[1]) and e0: return ("scset:" + e0, "LogicalType::BOOLEAN") + # generic (Set,Set)->Set|bool — base-typed (register over AllTypes), NOT name-scoped: + # the C names are _set_set (union/minus/intersection/contains/overlaps/...), which the + # name-based set_reg_scope misses. Mirror shape_span's contp detection. + if len(ins) == 2 and setp(ins[0]) and setp(ins[1]): + if rb == "Set" and rn.endswith("*"): return ("b_set", "LogicalType::BLOB") + if rb == "bool" and "*" not in rn: return ("b_bool", "LogicalType::BOOLEAN") + # (Set, scalar element) -> Set : setUnion/setMinus/setIntersection with an element value + if len(ins) == 2 and rb == "Set" and rn.endswith("*"): + e1 = selem(ins[1]) + if setp(ins[0]) and e1: return ("setsc_set:" + e1, "LogicalType::BLOB") + # (Set, scalar PARAM) -> Set where arg2 is NOT a set element (degrees(floatset, bool)): + # a same-set-type return whose trailing scalar is a fixed param, name-scoped to its set + # (set_*). Distinct from the element-add setsc_set above (arg2 co-varies there). + if (len(ins) == 2 and setp(ins[0]) and rb == "Set" and rn.endswith("*") + and not selem(ins[1]) and base(ins[1]["canonical"]) in SCALAR_ARG + and "*" not in norm(ins[1]["canonical"]) and set_reg_scope(f["name"])): + return ("setcsc:" + base(ins[1]["canonical"]), "LogicalType::BLOB") + if set_reg_scope(f["name"]) is None: return None + if len(ins) == 1 and setp(ins[0]): + if rb == "Set" and rn.endswith("*"): return ("u_set", "LogicalType::BLOB") + if rb in BYVAL_RET and "*" not in rn: return ("u_scalar:" + rb, byval_ret_duck(rb)) + if rb in ("text", "char") and rn.endswith("*"): return ("u_scalar:" + rb, "LogicalType::VARCHAR") + return None + return None + +def emit_set(f, kind): + name = f["name"] + if kind.startswith("setsc:"): # (Set, scalar) -> bool + e = kind.split(':')[1] + if e == "text": + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t a2) {{\n" + f" Set *s = BlobToSet(a);\n text *t2 = MakeText(a2);\n" + f" bool r = {name}(s, t2);\n free(t2); free(s);\n" + f" return r;\n }});\n}}\n") + _dt, cpp2, marsh = SCALAR_ARG[e] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, {cpp2} a2) {{\n" + f" Set *s = BlobToSet(a);\n bool r = {name}(s, {marsh});\n free(s);\n" + f" return r;\n }});\n}}\n") + if kind.startswith("setsc_set:"): # (Set, scalar element) -> Set + e = kind.split(':')[1] + if e == "text": + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t a2) {{\n" + f" Set *s = BlobToSet(a);\n text *t2 = MakeText(a2);\n" + f" Set *r = {name}(s, t2);\n free(t2); free(s);\n" + f" return SetToBlob(result, r);\n }});\n}}\n") + _dt, cpp2, marsh = SCALAR_ARG[e] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, {cpp2} a2) {{\n" + f" Set *s = BlobToSet(a);\n Set *r = {name}(s, {marsh});\n free(s);\n" + f" return SetToBlob(result, r);\n }});\n}}\n") + if kind.startswith("setcsc:"): # (Set, by-value scalar param) -> Set (degrees(floatset, bool)) + _dt, cpp2, marsh = SCALAR_ARG[kind.split(':')[1]] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, {cpp2} a2) {{\n" + f" Set *s = BlobToSet(a);\n Set *r = {name}(s, {marsh});\n free(s);\n" + f" return SetToBlob(result, r);\n }});\n}}\n") + if kind.startswith("scset:"): # (scalar, Set) -> bool + e = kind.split(':')[1] + if e == "text": + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a1, string_t b) {{\n" + f" text *t1 = MakeText(a1);\n Set *s = BlobToSet(b);\n" + f" bool r = {name}(t1, s);\n free(t1); free(s);\n" + f" return r;\n }});\n}}\n") + _dt, cpp1, marsh = SCALAR_ARG[e]; marsh = marsh.replace("a2", "a1") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute<{cpp1}, string_t, bool>(args.data[0], args.data[1], result, args.size(),\n" + f" [&]({cpp1} a1, string_t b) {{\n" + f" Set *s = BlobToSet(b);\n bool r = {name}({marsh}, s);\n free(s);\n" + f" return r;\n }});\n}}\n") + if kind == "u_set": # (Set) -> Set (pointer return; MEOS NULL -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Set *s = BlobToSet(in);\n Set *r = {name}(s);\n free(s);\n" + f" return SetToBlobN(result, r, mask, idx);\n }});\n}}\n") + if kind.startswith("u_scalar:"): + cct, rett, rexpr = byval_ret3(kind.split(':')[1]) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::Execute(args.data[0], result, args.size(),\n" + f" [&](string_t in) {{\n" + f" Set *s = BlobToSet(in);\n {cct} r = {name}(s);\n free(s);\n" + f" return {rexpr};\n }});\n}}\n") + if kind == "b_set": # (Set,Set) -> Set (pointer return; MEOS NULL -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Set *s1 = BlobToSet(a);\n Set *s2 = BlobToSet(b);\n" + f" Set *r = {name}(s1, s2);\n free(s1); free(s2);\n" + f" return SetToBlobN(result, r, mask, idx);\n }});\n}}\n") + else: # b_bool + inner = (f" bool r = {name}(s1, s2);\n free(s1); free(s2);\n return r;") + rett = "bool" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b) {{\n" + f" Set *s1 = BlobToSet(a);\n Set *s2 = BlobToSet(b);\n{inner}\n }});\n}}\n") + +def shape_emittable(f): + """Guaranteed-compilable AND correctly-scoped subset, or None. + To avoid emitting a wrong registration we take only the UNAMBIGUOUS shapes: + - scalar return (int/int64/double/bool) — correct for any temporal type; OR + - Temporal return from a GENERIC `temporal_*` transform — preserves temptype, + so ret==arg type is correct (conversions *_to_t* that CHANGE type are + excluded here; they need return-type-from-name = a later increment).""" + if supported(f) is not None: + return None + ins, out = classify(f) + if out is not None or len(ins) != 1: + return None + if base(ins[0]["canonical"]) != "Temporal" or not norm(ins[0]["canonical"]).endswith("*"): + return None + sc = reg_scope(f["name"]) + if sc is None: + return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + # A `const` temporal-pointer return is a BORROWED pointer into the input (MEOS `_p`/peek + # accessors, e.g. temporal_max_inst_p) — freeing the input or the result is a use-after-free, + # and every such peek has an owned non-const sibling with the same @sqlfn (temporal_max_instant). + # Take only the owned (non-const) return so the body's free(t)+TemporalToBlob stays correct. + if rb in TEMPORAL_PTR_RET and rn.endswith("*") and "const" not in f["returnType"]["canonical"]: + return ("temporal", "MD_TEMPORAL") # ret type resolved per-accessor via ret_temporal_type + if rb in BYVAL_RET and "*" not in rn: + return ("scalar:" + rb, scalar_ret_duck(f)) + if rb in ("Interval", "text", "char") and rn.endswith("*"): # owned-pointer scalar return (duration / text / cstring) + return ("scalar:" + rb, scalar_ret_duck(f)) + # base-value pointer return (Temporal accessor: startValue/endValue -> the family base value, + # e.g. tcbuffer_start_value -> Cbuffer *). reg_scope keys the per-type MEOS symbol to its own + # family (tcbuffer_ prefix -> tcbuffer only), so no cross-type over-registration; the owned + # pointer is marshalled + freed by {Base}ToBlobN. `const` returns are borrowed peeks — excluded. + if rb in BASEVAL_PTR_RET and rn.endswith("*") and "const" not in f["returnType"]["canonical"]: + return ("baseval:" + rb, PTR_RET[rb][0]) + # spatial accessor returning a geometry (TSpatial: convexHull -> the family's hull + # GSERIALIZED). The owned GSERIALIZED marshals to the DuckDB GEOMETRY via the geo helper + # (inverse of GeometryToGSerialized); reg_scope keys the per-type symbol to its own family. + if rb == "GSERIALIZED" and rn.endswith("*") and "const" not in f["returnType"]["canonical"]: + # The geo temporal types carry a HAND geometry-accessor layer (twCentroid/convexHull on + # tgeompoint/tgeogpoint/tgeometry/tgeography); a bare generated name double-registers + # against it. Emit only for the non-geo spatial families (tcbuffer, …) whose geometry + # accessors have no hand reg, until the geo hand layer is retired. + if sc[0] == "types" and set(sc[1]).issubset(set(GEO_ALLTYPES)): + return None + return ("geo", "GeoTypes::GEOMETRY()") + return None + +def emit_body(f, kind): + name, sqlfn = f["name"], f["sqlfn"] + # A concrete subtype return (TInstant */TSequence */TSequenceSet *) upcasts to Temporal * + # before the uniform temporal marshalling; a plain Temporal * return needs no cast. + subcast = "" if base(f["returnType"]["canonical"]) == "Temporal" else "(Temporal *) " + if kind == "temporal": # (Temporal) -> Temporal (pointer return; MEOS NULL -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" Temporal *r = {subcast}{name}(t);\n" + f" free(t);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n" + f" }});\n}}\n") + if kind.startswith("baseval:"): # (Temporal) -> base value ptr (startValue/endValue -> Cbuffer *) + rb = kind.split(":", 1)[1] # {Base}ToBlobN owns the free + NULL-safe marshalling + cct = norm(f["returnType"]["canonical"]) # e.g. "Cbuffer *" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {cct} r = {name}(t);\n" + f" free(t);\n" + f" return {rb}ToBlobN(result, r, mask, idx);\n" + f" }});\n}}\n") + if kind == "geo": # (Temporal) -> owned GSERIALIZED -> DuckDB GEOMETRY (freed after marshalling) + cct = norm(f["returnType"]["canonical"]) # "GSERIALIZED *" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &state, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {cct} r = {name}(t);\n" + f" free(t);\n" + f" if (!r) {{ mask.SetInvalid(idx); return string_t(); }}\n" + f" string_t out = GSerializedToGeometry(r, state, result);\n" + f" free(r);\n" + f" return out;\n" + f" }});\n}}\n") + cct, rett, rexpr = scalar_emit3(f) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::Execute(args.data[0], result, args.size(),\n" + f" [&](string_t in) {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {cct} r = {name}(t);\n" + f" free(t);\n" + f" return {rexpr};\n" + f" }});\n}}\n") + +# 2nd-arg scalar marshalling for binary Temporal+scalar fns: base -> (duck arg type, cpp type, MEOS-call expr from `a2`) +SCALAR_ARG = { + "int": ("LogicalType::INTEGER", "int32_t", "a2"), + "int32_t": ("LogicalType::INTEGER", "int32_t", "a2"), + "int64_t": ("LogicalType::BIGINT", "int64_t", "a2"), + "double": ("LogicalType::DOUBLE", "double", "a2"), + "bool": ("LogicalType::BOOLEAN", "bool", "a2"), + "TimestampTz": ("LogicalType::TIMESTAMP_TZ", "timestamp_tz_t", "DuckDBToMeosTimestamp(a2).value"), + "DateADT": ("LogicalType::DATE", "date_t", "ToMeosDate(a2)"), # single-expr, no lifecycle +} +def shape_binary(f): + """Binary Temporal + by-value-scalar shape (BinaryExecutor). Same correctness + rules as shape_emittable: scalar return OR generic same-type temporal return.""" + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + if base(ins[0]["canonical"]) != "Temporal" or not norm(ins[0]["canonical"]).endswith("*"): return None + b2 = base(ins[1]["canonical"]); n2 = norm(ins[1]["canonical"]) + is_text2 = (b2 == "text" and n2.endswith("*")) # owned text* arg via MakeText + is_baseptr2 = (b2 in BASEVAL_PTR_IN and n2.endswith("*")) # base value by pointer (Cbuffer, ...) + if not is_text2 and not is_baseptr2 and (b2 not in SCALAR_ARG or "*" in n2): return None + sc = reg_scope(f["name"]) + if sc is None: return None + if is_text2: + arg2 = ("LogicalType::VARCHAR", "string_t", "__TEXT__") + elif is_baseptr2: # marshal via PTR_IN (BlobTo) + free after + arg2 = (PTR_IN[b2][0], "string_t", "__PTRFREE__:" + b2) + else: + arg2 = SCALAR_ARG[b2] + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb in TEMPORAL_PTR_RET and rn.endswith("*"): + return ("temporal", "MD_TEMPORAL", arg2) + if rb in BYVAL_RET and "*" not in rn: + return ("scalar:" + rb, scalar_ret_duck(f), arg2) + if rb in ("Interval", "text", "char") and rn.endswith("*"): # owned-pointer scalar return + return ("scalar:" + rb, scalar_ret_duck(f), arg2) + return None + +def emit_body_binary(f, kind, arg2): + name = f["name"]; dt2, cpp2, marsh = arg2 + is_text = (marsh == "__TEXT__") + is_ptr = marsh.startswith("__PTRFREE__:") # base value by pointer: marshal via BlobTo, then free + if is_text: + pre, call2, post = "text *a2t = MakeText(a2);\n ", "a2t", "free(a2t); " + elif is_ptr: + pb = marsh.split(":", 1)[1] + pre, call2, post = f"{pb} *a2p = {PTR_IN[pb][1] % 'a2'};\n ", "a2p", "free(a2p); " + else: + pre, call2, post = "", marsh, "" + subcast = "" if base(f["returnType"]["canonical"]) == "Temporal" else "(Temporal *) " + if kind == "temporal": # pointer return -> NULL-safe (MEOS NULL -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {pre}Temporal *r = {subcast}{name}(t, {call2});\n {post}free(t);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n" + f" }});\n}}\n") + ctype, rett, _rx = scalar_emit3(f) + inner = f"{pre}{ctype} r = {name}(t, {call2});\n {post}free(t);\n return {_rx};" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2) {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {inner}\n" + f" }});\n}}\n") + +def header_symbols(incl_dir): + """Set of MEOS function names DECLARED in the target headers. The required + pin/ABI gate ([[meos-idl-for-binding-codegen]]): the catalog is version-fluid, + so only emit functions actually present at the BUILD pin (else link/compile + fails on catalog-ahead-of-pin functions like 14l tfloat_sin on an older pin).""" + import os + # Scan ONLY the MEOS C headers the generated TU actually #includes (its include + # closure). Globbing every *.h admits symbols from family headers we do NOT + # include — they pass the gate but are undeclared at compile time. Keep this list + # in lockstep with the preamble's C #includes: meos_wrapper_simple.hpp now pulls in + # every per-family public header (cross-family conversions like tbigint_to_th3index, + # tgeometry_to_tcbuffer, ttext_to_tjsonb live there, not in the meos.h umbrella — + # the port builds all families so all are installed), so the gate must see them too. + TU_C_HEADERS = ("meos.h", "meos_catalog.h", "meos_internal.h", + "meos_geo.h", "meos_internal_geo.h", + "meos_cbuffer.h", "meos_h3.h", "meos_json.h", "meos_npoint.h", + "meos_pointcloud.h", "meos_pose.h", "meos_quadbin.h", "meos_rgeo.h", + "pg_date.h", "pg_timestamp.h") + syms = set() + for name in TU_C_HEADERS: + h = os.path.join(incl_dir, name) + if not os.path.exists(h): + continue + try: + for line in open(h, errors="ignore"): + m = re.search(r'\b([a-z][a-z0-9_]+)\s*\(', line) + # A prototype counts if it is `extern`-qualified OR starts with a MEOS + # return type. The width-suffixed stdint types (int32_t/uint64/…) are + # included so by-value integer accessors like `int32_t tspatial_srid(...)` + # are seen by the gate — otherwise the plain `int `/`bool ` prefixes miss + # them and the function is silently dropped from the generated surface. + if m and ("extern" in line or line.lstrip().startswith(( + "int ", "bool ", "double ", "Temporal ", "void ", + "int8 ", "int16 ", "int32 ", "int64 ", + "uint8 ", "uint16 ", "uint32 ", "uint64 ", + "int8_t ", "int16_t ", "int32_t ", "int64_t ", + "uint8_t ", "uint16_t ", "uint32_t ", "uint64_t ", "size_t "))): + syms.add(m.group(1)) + except OSError: + pass + return syms + +def shape_ternary(f): + """Ternary Temporal + 2 by-value scalars (TernaryExecutor). Same correctness rules.""" + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 3: return None + if base(ins[0]["canonical"]) != "Temporal" or not norm(ins[0]["canonical"]).endswith("*"): return None + b2 = base(ins[1]["canonical"]); b3 = base(ins[2]["canonical"]) + if b2 not in SCALAR_ARG or "*" in norm(ins[1]["canonical"]): return None + if b3 not in SCALAR_ARG or "*" in norm(ins[2]["canonical"]): return None + if reg_scope(f["name"]) is None: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "Temporal" and rn.endswith("*"): + return ("temporal", "MD_TEMPORAL", SCALAR_ARG[b2], SCALAR_ARG[b3]) + if rb in BYVAL_RET and "*" not in rn: + return ("scalar:" + rb, scalar_ret_duck(f), SCALAR_ARG[b2], SCALAR_ARG[b3]) + return None + +def emit_body_ternary(f, kind, arg2, arg3): + name = f["name"]; dt2, cpp2, _ = arg2; dt3, cpp3, _ = arg3 + e2 = arg2[2]; e3 = arg3[2].replace("a2", "a3") # SCALAR_ARG marshal is templated on "a2" + if kind == "temporal": # ternary -> Temporal (NULL-safe pointer return) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" TernaryExecutor::ExecuteWithNulls(" + f"args.data[0], args.data[1], args.data[2], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2, {cpp3} a3, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" Temporal *r = {name}(t, {e2}, {e3});\n free(t);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n }});\n}}\n") + ctype, rett, _rx = scalar_emit3(f) + inner = f"{ctype} r = {name}(t, {e2}, {e3});\n free(t);\n return {_rx};" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" TernaryExecutor::Execute(" + f"args.data[0], args.data[1], args.data[2], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2, {cpp3} a3) {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {inner}\n" + f" }});\n}}\n") + +def shape_binary_tt(f): + """Binary Temporal + Temporal (both via BlobToTemporal) — the big 2-arg shape + (comparisons, boolean ops, distance, etc.). Both args same temporal type.""" + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + if not all(base(p["canonical"]) == "Temporal" and norm(p["canonical"]).endswith("*") for p in ins): + return None + if reg_scope(f["name"]) is None: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "Temporal" and rn.endswith("*"): + return ("temporal", "MD_TEMPORAL") + if rb in BYVAL_RET and "*" not in rn: + return ("scalar:" + rb, scalar_ret_duck(f)) + return None + +def emit_binary_tt(f, kind): + name = f["name"] + if kind == "temporal": # (Temporal,Temporal) -> Temporal (NULL-safe pointer return) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in1, string_t in2, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t1 = BlobToTemporal(in1);\n Temporal *t2 = BlobToTemporal(in2);\n" + f" Temporal *r = {name}(t1, t2);\n free(t1); free(t2);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n }});\n}}\n") + ctype, rett, _rx = scalar_emit3(f) + inner = f"{ctype} r = {name}(t1, t2);\n free(t1); free(t2);\n return {_rx};" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in1, string_t in2) {{\n" + f" Temporal *t1 = BlobToTemporal(in1);\n" + f" Temporal *t2 = BlobToTemporal(in2);\n" + f" {inner}\n" + f" }});\n}}\n") + +def shape_binary_tt_scalar(f): + """Two Temporal blobs + one trailing by-value scalar (TernaryExecutor over two + Temporal args and a scalar). E.g. temporal_lcss_distance(Temporal,Temporal,double) + — the similarity distance with a threshold. Same correctness rules as binary_tt.""" + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 3: return None + if not all(base(ins[i]["canonical"]) == "Temporal" and norm(ins[i]["canonical"]).endswith("*") + for i in (0, 1)): + return None + b3 = base(ins[2]["canonical"]) + if b3 not in SCALAR_ARG or "*" in norm(ins[2]["canonical"]): return None + if reg_scope(f["name"]) is None: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "Temporal" and rn.endswith("*"): + return ("temporal", "MD_TEMPORAL", SCALAR_ARG[b3]) + if rb in BYVAL_RET and "*" not in rn: + return ("scalar:" + rb, scalar_ret_duck(f), SCALAR_ARG[b3]) + return None + +def emit_binary_tt_scalar(f, kind, arg3): + name = f["name"]; dt3, cpp3, e3 = arg3 # SCALAR_ARG marshal is templated on "a2" + if kind == "temporal": # (Temporal,Temporal,scalar) -> Temporal (NULL-safe) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" TernaryExecutor::ExecuteWithNulls(" + f"args.data[0], args.data[1], args.data[2], result, args.size(),\n" + f" [&](string_t in1, string_t in2, {cpp3} a2, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t1 = BlobToTemporal(in1);\n Temporal *t2 = BlobToTemporal(in2);\n" + f" Temporal *r = {name}(t1, t2, {e3});\n free(t1); free(t2);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n }});\n}}\n") + ctype, rett, _rx = scalar_emit3(f) + inner = f"{ctype} r = {name}(t1, t2, {e3});\n free(t1); free(t2);\n return {_rx};" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" TernaryExecutor::Execute(" + f"args.data[0], args.data[1], args.data[2], result, args.size(),\n" + f" [&](string_t in1, string_t in2, {cpp3} a2) {{\n" + f" Temporal *t1 = BlobToTemporal(in1);\n" + f" Temporal *t2 = BlobToTemporal(in2);\n" + f" {inner}\n" + f" }});\n}}\n") + +def shape_geo_temporal(f): + """Geometry-argument spatial relationships: one Temporal blob + one GSERIALIZED + (geometry) blob, optional trailing double. The geometry is marshalled + GeometryToGSerialized(blob, tspatial_srid(t)) — its SRID comes from the sibling + temporal arg (the hand geo executor pattern, tgeompoint_functions.cpp). Covers the + geo spatial relationships eContains/eIntersects/eDwithin/... (group *_rel_ever: MEOS + `int` tri-state, ret<0 -> SQL NULL, else BOOLEAN) and tContains/tIntersects/tDwithin/... + (group *_rel_temp: Temporal tbool). supported() rejects the GSERIALIZED arg, so the + non-arg eligibility checks are applied directly here.""" + name = f["name"] + if name.startswith("meos_internal") or (f.get("group") or "").startswith("meos_internal"): + return None + if not f.get("sqlfn") or re.search(r'_(out|in|send|recv)$', f.get("sqlfn") or ""): + return None + if unregistered_family_ref(name) is not None: + return None + ins, out = classify(f) + if out is not None or len(ins) not in (2, 3): + return None + bs = [base(p["canonical"]) for p in ins] + # first two args = exactly one Temporal* and one GSERIALIZED* (either order), both ptrs + if sorted(bs[:2]) != ["GSERIALIZED", "Temporal"]: + return None + if not all(norm(ins[i]["canonical"]).endswith("*") for i in (0, 1)): + return None + geo_first = (bs[0] == "GSERIALIZED") + has_dbl = len(ins) == 3 + if has_dbl and (base(ins[2]["canonical"]) != "double" or "*" in norm(ins[2]["canonical"])): + return None + # A geo spatial-RELATIONSHIP backing (group *_rel_ever / *_rel_temp) is admitted even when + # the name heuristic leaves it unscoped: the point-specific _tpoint_geo touches carry no + # reg_scope token (etouches_tpoint_geo -> None), yet they are the correct trajectory-based + # backing for temporal points. Its exact per-type scope comes from the catalog sqlSignatures + # in gen_cpp (sig_declared_accs), not this heuristic. + if reg_scope(name) is None and not re.search(r'_rel_(ever|temp)$', f.get("group") or ""): + return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "Temporal" and rn.endswith("*"): + return ("temporal", "MD_TEMPORAL", geo_first, has_dbl) + if rb in ("int", "int32_t") and "*" not in rn: # ea tri-state -> nullable BOOLEAN + return ("scalar", scalar_ret_duck(f), geo_first, has_dbl) + return None + +def emit_geo_temporal(f, kind, geo_first, has_dbl): + name = f["name"] + decl = "string_t in_g, string_t in_t" if geo_first else "string_t in_t, string_t in_g" + call_args = "gs, t" if geo_first else "t, gs" + # When the temporal operand is geodetic, coerce the geometry to geography so the + # planar/geodetic flags + bbox match before the MEOS call (MEOS correctly errors on a + # mixed planar/geodetic pair). DuckDB has a single GEOMETRY type, so this cross-argument + # coercion is the binding's job; the SRID likewise comes from the sibling temporal. + marshal = (" Temporal *t = BlobToTemporal(in_t);\n" + " GSERIALIZED *gs = GeometryToGSerialized(in_g, tspatial_srid(t));\n" + " if (MEOS_FLAGS_GET_GEODETIC(t->flags)) {\n" + " GSERIALIZED *gs_geog = geom_to_geog(gs);\n" + " free(gs); gs = gs_geog;\n" + " }\n") + freeing = " free(t); free(gs);\n" + if has_dbl: # (Temporal,geometry,double) or (geometry,Temporal,double) + exec_head = ("TernaryExecutor::ExecuteWithNulls(" + "args.data[0], args.data[1], args.data[2], result, args.size(),") + lam_decl = decl + ", double d, ValidityMask &mask, idx_t idx" + call = f"{name}({call_args}, d)" + else: # (Temporal,geometry) or (geometry,Temporal) + exec_head = ("BinaryExecutor::ExecuteWithNulls(" + "args.data[0], args.data[1], result, args.size(),") + lam_decl = decl + ", ValidityMask &mask, idx_t idx" + call = f"{name}({call_args})" + if kind == "temporal": # -> Temporal tbool (NULL-safe pointer return) + head = exec_head.format(ret="string_t"); rett = "string_t" + body = (f" Temporal *r = {call};\n{freeing}" + f" return TemporalToBlobN(result, r, mask, idx);\n") + else: # ea int -> nullable BOOLEAN (hand semantics: ret<0 -> SQL NULL) + head = exec_head.format(ret="bool"); rett = "bool" + body = (f" int r = {call};\n{freeing}" + f" if (r < 0) {{ mask.SetInvalid(idx); return false; }}\n" + f" return r != 0;\n") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" {head}\n" + f" [&]({lam_decl}) -> {rett} {{\n{marshal}{body} }});\n}}\n") + +# ---- array-return struct shape: C array-of-structs + int* count -> DuckDB LIST(STRUCT) ---- +# Driven ENTIRELY by the catalog: shape.arrayReturn (from MEOS-API shapeinfer) marks the +# array return, lengthFrom.name identifies the count out-param, and the returned struct's +# fields come from the catalog `structs` table. The similarity *Path fns (frechet/dtw) are +# the instance: (Temporal, Temporal) -> Match* + int* count -> LIST(STRUCT(i,j)). The body +# mirrors the hand RunSimilarityPath; the type mirrors temporal.cpp's path_type. STRUCTS is +# populated from the catalog in main(). +STRUCTS = {} +PATH_LT = {"int": "LogicalType::INTEGER", "int64": "LogicalType::BIGINT", + "double": "LogicalType::DOUBLE", "bool": "LogicalType::BOOLEAN"} +PATH_CPP = {"int": "int32_t", "int64": "int64_t", "double": "double", "bool": "bool"} + +def path_logical_type(flds): + members = ", ".join('{"%s", %s}' % (fl["name"], PATH_LT.get(fl["cType"], "LogicalType::INTEGER")) + for fl in flds) + return "LogicalType::LIST(LogicalType::STRUCT({%s}))" % members + +def shape_path(f): + """Binary Temporal+Temporal whose catalog shape.arrayReturn returns a C array of a known + struct (+ int* count out-param) -> a DuckDB LIST(STRUCT(...)). The frechet/dtw *Path fns. + NOTE: this shape's struct-pointer return is exactly what supported() rejects ('ret:Match *'), + so we apply only the user-facing eligibility checks here, not the standard ret/arg gate.""" + name = f["name"] + if name.startswith("meos_internal") or (f.get("group") or "").startswith("meos_internal"): + return None + if not f.get("sqlfn") or re.search(r'_(out|in|send|recv)$', f.get("sqlfn") or ""): + return None + ar = (f.get("shape") or {}).get("arrayReturn") + if not ar: return None + rb = base(f["returnType"]["canonical"]) + flds = (STRUCTS.get(rb) or {}).get("fields") + if not flds: return None # only struct-element arrays handled here + lf = ar.get("lengthFrom") or {} + if lf.get("kind") != "param" or not lf.get("name"): return None + ins = [p for p in f["params"] if p.get("name") != lf["name"]] # drop the count out-param + if len(ins) != 2: return None + if not all(base(p["canonical"]) == "Temporal" and norm(p["canonical"]).endswith("*") for p in ins): + return None + if reg_scope(f["name"]) is None: return None + return ("path", path_logical_type(flds)) + +def emit_path_table(f): + """DuckDB TABLE function for a catalog array-return-struct fn (the canonical SETOF surface, + e.g. frechetDistancePath -> RETURNS SETOF warp). Mirrors the hand SimilarityPath bind/init/exec; + return schema + per-row marshalling are field-driven from the catalog struct (warp/Match).""" + name = f["name"]; sqlfn = f["sqlfn"] + rb = base(f["returnType"]["canonical"]); flds = STRUCTS[rb]["fields"] + state_cols = "".join(f" std::vector<{PATH_CPP.get(fl['cType'],'int32_t')}> col{i};\n" + for i, fl in enumerate(flds)) + ret_types = ", ".join(PATH_LT.get(fl["cType"], "LogicalType::INTEGER") for fl in flds) + names_list = ", ".join('"%s"' % fl["name"] for fl in flds) + reserve = "".join(f" state->col{i}.reserve(count);\n" for i in range(len(flds))) + fill = "".join(f" state->col{i}.push_back(path[k].{fl['name']});\n" + for i, fl in enumerate(flds)) + out_decls = "".join(f" auto out{i} = FlatVector::GetData<{PATH_CPP.get(fl['cType'],'int32_t')}>(output.data[{i}]);\n" + for i, fl in enumerate(flds)) + out_fill = "".join(f" out{i}[k] = state.col{i}[state.idx + k];\n" for i in range(len(flds))) + return ( +f"struct PathBind_{name} : public TableFunctionData {{ string_t a, b; }};\n" +f"struct PathState_{name} : public GlobalTableFunctionState {{\n" +f" idx_t idx = 0;\n{state_cols}}};\n" +f"static unique_ptr PathBindFn_{name}(ClientContext &, TableFunctionBindInput &input,\n" +f" vector &return_types, vector &names) {{\n" +f" if (input.inputs.size() != 2 || input.inputs[0].IsNull() || input.inputs[1].IsNull())\n" +f" throw BinderException(\"{sqlfn}: expects two non-null temporal arguments\");\n" +f" auto bind = make_uniq();\n" +f" bind->a = StringValue::Get(input.inputs[0]);\n" +f" bind->b = StringValue::Get(input.inputs[1]);\n" +f" return_types = {{{ret_types}}};\n" +f" names = {{{names_list}}};\n" +f" return std::move(bind);\n}}\n" +f"static unique_ptr PathInit_{name}(ClientContext &, TableFunctionInitInput &input) {{\n" +f" EnsureMeosThreadInitialized();\n" +f" auto &bind = input.bind_data->Cast();\n" +f" auto state = make_uniq();\n" +f" Temporal *t1 = BlobToTemporal(bind.a);\n" +f" Temporal *t2 = BlobToTemporal(bind.b);\n" +f" int count = 0;\n" +f" {rb} *path = {name}(t1, t2, &count);\n" +f" free(t1); free(t2);\n" +f" if (path) {{\n{reserve}" +f" for (int k = 0; k < count; k++) {{\n{fill} }}\n" +f" free(path);\n }}\n" +f" return std::move(state);\n}}\n" +f"static void PathExec_{name}(ClientContext &, TableFunctionInput &input, DataChunk &output) {{\n" +f" auto &state = input.global_state->Cast();\n" +f" idx_t total = state.col0.size();\n" +f" idx_t count = MinValue(STANDARD_VECTOR_SIZE, total - state.idx);\n" +f"{out_decls} for (idx_t k = 0; k < count; k++) {{\n{out_fill} }}\n" +f" state.idx += count;\n output.SetCardinality(count);\n}}\n") + +# ---- general array-return shape: * + int* count -> DuckDB LIST() ---- +# The flat-LIST general case of shape_path (which handles the LIST(STRUCT) *Path structs). +# Entirely catalog-driven: shape.arrayReturn carries the element type (from MEOS-API shapeinfer) +# and lengthFrom.name the trailing int* count out-param. Element marshalling is ONE boundary +# table keyed on the canonical element type (zero heuristics): a scalar element goes to a typed +# child vector; a text* element to a VARCHAR child (each varlena freed); a MEOS value-type struct +# (Span/STBox/TBox) to a BLOB child by sizeof (the array is freed once, elements are inline). +# elem canonical(normalized) -> (LIST child LogicalType, child C++ type, per-element marshal stmt) +ARRAY_ELEM = { + "int": ("LogicalType::INTEGER", "int32_t", "cd[off + j] = arr[j];"), + "int32_t": ("LogicalType::INTEGER", "int32_t", "cd[off + j] = arr[j];"), + "int64_t": ("LogicalType::BIGINT", "int64_t", "cd[off + j] = arr[j];"), + "double": ("LogicalType::DOUBLE", "double", "cd[off + j] = arr[j];"), + "bool": ("LogicalType::BOOLEAN", "bool", "cd[off + j] = arr[j];"), + # date/timestamp elements carry the MEOS (PG) epoch: convert to the DuckDB epoch with the + # same helpers the scalar-return bodies use (TakeTimestamp / FromMeosDate), never a raw cast. + "TimestampTz": ("LogicalType::TIMESTAMP_TZ", "timestamp_tz_t", "cd[off + j] = TakeTimestamp(arr[j]);"), + "DateADT": ("LogicalType::DATE", "date_t", "cd[off + j] = FromMeosDate((int32_t) arr[j]);"), + "text *": ("LogicalType::VARCHAR", "string_t", "cd[off + j] = TakeText(child_vector, arr[j]);"), + "Span": ("LogicalType::BLOB", "string_t", + "cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(Span));"), + "STBox": ("LogicalType::BLOB", "string_t", + "cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(STBox));"), + "TBox": ("LogicalType::BLOB", "string_t", + "cd[off + j] = StringVector::AddStringOrBlob(child_vector, (const char *) &arr[j], sizeof(TBox));"), +} +# container-input family (base of the single non-count param) -> (C container type, Blob->container fn) +ARRAY_IN = { + "Set": ("Set", "BlobToSet"), + "SpanSet": ("SpanSet", "BlobToSpanSet"), + "Temporal": ("Temporal", "BlobToTemporal"), + "TInstant": ("Temporal", "BlobToTemporal"), + "TSequence": ("Temporal", "BlobToTemporal"), + "TSequenceSet": ("Temporal", "BlobToTemporal"), +} + +def shape_tgeoarr(f): + """The NxN set-set functions take two arrays-of-temporal (const Temporal ** + int count) pairs. + Two catalog shapes are emitted as DuckDB scalars over LIST() x LIST(): + minDistance(tgeo[],tgeo[]) -> double = ('scalar_double',) + the *Pairs SRFs: int* flattened [i,j] pairs + int* count (+ double dist, + SpanSet*** periods) + -> LIST(STRUCT(i,j[,periods])) = ('pairs', has_dist, has_periods) + The Temporal** args make base()=='__INTERNAL__' so every other shape rejects them, so this shape + applies its own eligibility checks. The *Pairs result is a scalar LIST(STRUCT) (UNNEST to rows), + NOT a table fn: the BerlinMOD q06/q10 args are per-row collect_list LISTs, which a DuckDB table + fn (bind-time-const args) cannot take without LATERAL.""" + name = f["name"] + if name.startswith("meos_internal") or (f.get("group") or "").startswith("meos_internal"): + return None + if not f.get("sqlfn") or re.search(r'_(out|in|send|recv)$', f.get("sqlfn") or ""): + return None + ps = f["params"] + def is_temp_arr(p): return norm(p["canonical"]) == "Temporal **" + def is_int(p): return base(p["canonical"]) in ("int", "int32_t") and "*" not in norm(p["canonical"]) + # both forms begin (const Temporal ** arr1, int count1, const Temporal ** arr2, int count2) + if len(ps) < 4 or not (is_temp_arr(ps[0]) and is_int(ps[1]) and is_temp_arr(ps[2]) and is_int(ps[3])): + return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if len(ps) == 4 and rb == "double" and "*" not in rn: + return ("scalar_double",) + # *Pairs: int* return with a catalog arrayReturn (flattened index pairs) + int* count out-param + ar = (f.get("shape") or {}).get("arrayReturn") + if ar and rb == "int" and rn.endswith("*"): + pnames = [p.get("name") for p in ps] + return ("pairs", "dist" in pnames, "periods" in pnames) + return None + +def emit_tgeoarr_scalar(f): + """DuckDB scalar over two LIST(temporal-blob) args -> double (minDistance). Each LIST row is + marshalled to a fresh Temporal** via ListToTemporalArr, the MEOS kernel called, the arrays freed.""" + name = f["name"] + return ( +f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" +f" EnsureMeosThreadInitialized();\n" +f" auto &lv1 = args.data[0]; auto &lv2 = args.data[1];\n" +f" auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1));\n" +f" auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2));\n" +f" BinaryExecutor::Execute(\n" +f" lv1, lv2, result, args.size(),\n" +f" [&](list_entry_t le1, list_entry_t le2) -> double {{\n" +f" int n1, n2;\n" +f" const Temporal **a1 = ListToTemporalArr(child1, le1, &n1);\n" +f" const Temporal **a2 = ListToTemporalArr(child2, le2, &n2);\n" +f" double r = {name}(a1, n1, a2, n2);\n" +f" FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2);\n" +f" return r;\n" +f" }});\n}}\n") + +def emit_pairs_scalar(f, has_dist, has_periods): + """DuckDB scalar over two LIST(temporal-blob) args (+ optional double dist) -> a + LIST(STRUCT(i INTEGER, j INTEGER[, periods TSTZSPANSET])) (the NxN *Pairs SRFs). The MEOS kernel + returns a flattened [i0,j0,i1,j1,...] int array of `count` index pairs (+ for the t-variants a + parallel SpanSet** of `count` tstzspansets); each row is reshaped into a DuckDB LIST(STRUCT) that + UNNEST expands to rows. Mirrors emit_array's Reserve/SetListSize LIST-build over a STRUCT child.""" + name = f["name"] + dist_flat = (" args.data[2].Flatten(row_count);\n" + " auto dd = FlatVector::GetData(args.data[2]);\n") if has_dist else "" + dist_arg = "dd[r], " if has_dist else "" + per_decl = " SpanSet **periods = nullptr;\n" if has_periods else "" + per_arg = ", &periods" if has_periods else "" + per_field = " auto &pv = *sf[2];\n" if has_periods else "" + per_fill = (" FlatVector::GetData(pv)[off + k] = SpanSetToBlob(pv, periods[k]);\n" + if has_periods else "") + # Each periods[k] SpanSet* is consumed+freed by SpanSetToBlob above; free only the outer array. + per_free = " if (periods) free(periods);\n" if has_periods else "" + return ( +f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" +f" EnsureMeosThreadInitialized();\n" +f" idx_t row_count = args.size();\n" +f" auto &lv1 = args.data[0]; auto &lv2 = args.data[1];\n" +f" lv1.Flatten(row_count); lv2.Flatten(row_count);\n" +f" auto le1 = FlatVector::GetData(lv1);\n" +f" auto le2 = FlatVector::GetData(lv2);\n" +f" auto &v1 = FlatVector::Validity(lv1);\n" +f" auto &v2 = FlatVector::Validity(lv2);\n" +f" auto &child1 = ListVector::GetEntry(lv1); child1.Flatten(ListVector::GetListSize(lv1));\n" +f" auto &child2 = ListVector::GetEntry(lv2); child2.Flatten(ListVector::GetListSize(lv2));\n" +f"{dist_flat}" +f" auto list_entries = FlatVector::GetData(result);\n" +f" auto &result_validity = FlatVector::Validity(result);\n" +f" idx_t off = 0;\n" +f" for (idx_t r = 0; r < row_count; r++) {{\n" +f" if (!v1.RowIsValid(r) || !v2.RowIsValid(r)) {{\n" +f" result_validity.SetInvalid(r); list_entries[r] = list_entry_t{{off, 0}}; continue;\n" +f" }}\n" +f" int n1, n2;\n" +f" const Temporal **a1 = ListToTemporalArr(child1, le1[r], &n1);\n" +f" const Temporal **a2 = ListToTemporalArr(child2, le2[r], &n2);\n" +f" int cnt = 0;\n" +f"{per_decl}" +f" int *res = {name}(a1, n1, a2, n2, {dist_arg}&cnt{per_arg});\n" +f" FreeTemporalArr(a1, n1); FreeTemporalArr(a2, n2);\n" +f" int n = (res && cnt > 0) ? cnt : 0;\n" +f" ListVector::Reserve(result, off + n);\n" +f" ListVector::SetListSize(result, off + n);\n" +f" list_entries[r] = list_entry_t{{off, (uint64_t) n}};\n" +f" if (n > 0) {{\n" +f" auto &sv = ListVector::GetEntry(result);\n" +f" auto &sf = StructVector::GetEntries(sv);\n" +f" auto id = FlatVector::GetData(*sf[0]);\n" +f" auto jd = FlatVector::GetData(*sf[1]);\n" +f"{per_field}" +f" for (int k = 0; k < n; k++) {{\n" +f" id[off + k] = res[2 * k];\n" +f" jd[off + k] = res[2 * k + 1];\n" +f"{per_fill}" +f" }}\n" +f" off += n;\n" +f" }}\n" +f" if (res) free(res);\n" +f"{per_free}" +f" result_validity.SetValid(r);\n" +f" }}\n" +f" if (row_count == 1) result.SetVectorType(VectorType::CONSTANT_VECTOR);\n" +f"}}\n") + +def _acc_sqlname(acc): + """The canonical SQL type name inside an accessor string, e.g. SetTypes::intset() -> intset, + TemporalTypes::tbool() -> tbool (the meos_catalog.c lowercase name the sqlSignatures key on).""" + m = re.search(r'::(\w+)\(\)', acc) + return m.group(1) if m else acc + +def _sig_ret_for(f, sqlname): + """The catalog sqlSignature return for the single-arg overload on SQL type `sqlname`, else None.""" + for s in (f.get("sqlSignatures") or []): + if s.get("args") == [sqlname]: + return s.get("ret") + return None + +def array_declared_accs(f): + """The registered DuckDB accessors this array-return is CREATE FUNCTION'd for, from the catalog + sqlSignatures whose SQL return is an array (`[]`). Extended/unregistered arg types map to + no accessor and drop out. This is the SoT for a generic (scope='all') array-return's type set, + excluding types whose canonical return is NOT an array (e.g. set_spans over textset: no sig).""" + m = {**SET_TYPES, **SPANSET_TYPES, **SIG_TEMPORAL_ACC} + out = [] + for s in (f.get("sqlSignatures") or []): + if len(s.get("args", [])) != 1 or not (s.get("ret") or "").endswith("[]"): + continue + a = m.get(s["args"][0]) + if a and a not in out: + out.append(a) + return out + +# The DuckDB LIST child LOGICAL type, keyed on the canonical SQL array element (the sig ret base). +# Struct-blob elements use the NAMED span/box type (BLOB-backed, but typed so results display / +# typeof / cast like the hand surface), not a raw BLOB. Physical marshalling stays keyed on the C +# element (ARRAY_ELEM); this only fixes the LOGICAL element type per the catalog sqlSignatures. +SQL_BASE_TO_DUCK = { + "integer": "LogicalType::INTEGER", "bigint": "LogicalType::BIGINT", "float": "LogicalType::DOUBLE", + "boolean": "LogicalType::BOOLEAN", "text": "LogicalType::VARCHAR", "date": "LogicalType::DATE", + "timestamptz": "LogicalType::TIMESTAMP_TZ", + "intspan": "SpanTypes::intspan()", "bigintspan": "SpanTypes::bigintspan()", + "floatspan": "SpanTypes::floatspan()", "datespan": "SpanTypes::datespan()", + "tstzspan": "SpanTypes::tstzspan()", "tbox": "TboxType::tbox()", "stbox": "StboxType::stbox()", +} + +def array_ret_duck(f, acc): + """The DuckDB LIST return type for this array-return on input accessor `acc`, from the catalog + sqlSignature (e.g. spans(intset)->intspan[] -> LIST(SpanTypes::intspan())). None if not an + array sig or the element type is not mapped (deferred).""" + r = _sig_ret_for(f, _acc_sqlname(acc)) or "" + if not r.endswith("[]"): + return None + d = SQL_BASE_TO_DUCK.get(r[:-2]) + return "LogicalType::LIST(%s)" % d if d else None + +def shape_array(f): + """Flat array-return -> DuckDB LIST(). Like shape_path, the trailing int* count arg + makes supported() reject it (arg:int *), so gate on user-facing eligibility + a single + marshallable container input, not the standard arg gate. Returns ('array', elem_canon, + in_base, scope, accs) or None. Geo/extended element types (GSERIALIZED*/Cbuffer*/... ) and + multi-arg array-returns (*Pairs/splitN, table-fn shapes) are not in ARRAY_ELEM -> deferred. + + CANONICAL GATE (the catalog sqlSignatures are the SoT): a LIST overload is emitted for an input + type ONLY where MobilityDB's SQL surface returns a SQL array (`[]`) for it. Several MEOS + accessors carry @sqlfn=getValues but their canonical SQL return is a spanset/set, not an array + (getValues(tint)->intspanset via Tnumber_valuespans; getValues(ttext)->textset), so no LIST + overload is emitted for them.""" + name = f["name"] + if name.startswith("meos_internal") or (f.get("group") or "").startswith("meos_internal"): + return None + sqlfn = f.get("sqlfn") + if not sqlfn or re.search(r'_(out|in|send|recv)$', sqlfn): + return None + if name.endswith("_p"): + return None # internal pointer-preserving twin (temporal_sequences_p) + ar = (f.get("shape") or {}).get("arrayReturn") + if not ar: + return None + # NB: no STRUCTS-fields exclusion here — the MEOS value-type structs Span/STBox/TBox ARE handled + # (as opaque BLOB elements, in ARRAY_ELEM); the LIST(STRUCT) path structs (Match/warp) are routed + # out below because their element is not in ARRAY_ELEM (shape_path handles those separately). + lf = ar.get("lengthFrom") or {} + if lf.get("kind") != "param" or not lf.get("name"): + return None + ec = norm((ar.get("element") or {}).get("canonical") or (ar.get("element") or {}).get("c") or "") + if ec not in ARRAY_ELEM: + return None + ins = [p for p in f["params"] if p.get("name") != lf["name"]] + if len(ins) != 1: + return None + ib = base(ins[0]["canonical"]) + if ib not in ARRAY_IN or not norm(ins[0]["canonical"]).endswith("*"): + return None + sc = set_reg_scope(name) if ib == "Set" else spanset_reg_scope(name) if ib == "SpanSet" else reg_scope(name) + if sc is None: + return None + scope, accs = sc + if scope == "all": + accs = array_declared_accs(f) # generic C fn: sig-declared types (SoT) + else: + accs = [a for a in accs if (_sig_ret_for(f, _acc_sqlname(a)) or "").endswith("[]")] + if not accs: + return None + return ("array", ec, ib, accs) + +def emit_array(f, ec, ib): + """The Gen_ body: marshal the container in, call the MEOS accessor with a local count, + and build a DuckDB LIST from the returned * array (per-element marshal from ARRAY_ELEM). + Reserve grows the child capacity to the running total; GetEntry is re-fetched after Reserve.""" + name = f["name"] + cbase, blobto = ARRAY_IN[ib] + _lt, ccpp, marsh = ARRAY_ELEM[ec] + retc = norm(f["returnType"]["canonical"]) # e.g. "TimestampTz *", "text **", "Span *" + return ( +f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" +f" EnsureMeosThreadInitialized();\n" +f" auto &in_vec = args.data[0];\n" +f" idx_t row_count = args.size();\n" +f" in_vec.Flatten(row_count);\n" +f" auto &result_validity = FlatVector::Validity(result);\n" +f" auto list_entries = FlatVector::GetData(result);\n" +f" idx_t off = 0;\n" +f" for (idx_t i = 0; i < row_count; ++i) {{\n" +f" if (in_vec.GetValue(i).IsNull()) {{ result_validity.SetInvalid(i); continue; }}\n" +f" string_t blob = FlatVector::GetData(in_vec)[i];\n" +f" {cbase} *in = {blobto}(blob);\n" +f" int count = 0;\n" +f" {retc} arr = {name}(in, &count);\n" +f" free(in);\n" +f" int n = (arr && count > 0) ? count : 0;\n" +f" ListVector::Reserve(result, off + n);\n" +f" ListVector::SetListSize(result, off + n);\n" +f" list_entries[i] = list_entry_t{{off, (uint64_t) n}};\n" +f" if (n > 0) {{\n" +f" auto &child_vector = ListVector::GetEntry(result);\n" +f" child_vector.SetVectorType(VectorType::FLAT_VECTOR);\n" +f" auto *cd = FlatVector::GetData<{ccpp}>(child_vector);\n" +f" for (int j = 0; j < n; ++j) {{ {marsh} }}\n" +f" off += n;\n" +f" }}\n" +f" if (arr) free(arr);\n" +f" result_validity.SetValid(i);\n" +f" }}\n" +f"}}\n") + +# Temporal + box (STBox/TBox) -> bool: the spatiotemporal/numeric topological predicates +# (contains/overlaps/contained/adjacent/same/left/right/... between a temporal and a box). +# Mixed-arg shape (one Temporal blob + one box blob); temporal scope from reg_scope +# (tspatial->geo for STBox, tnumber->{tint,tfloat} for TBox). +BOX_MARSH = {"STBox": ("BlobToStbox", "StboxType::stbox()"), + "TBox": ("BlobToTbox", "TboxType::tbox()")} +def shape_temporal_box(f): + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb != "bool" or "*" in rn: return None + b0 = base(ins[0]["canonical"]); n0 = norm(ins[0]["canonical"]) + b1 = base(ins[1]["canonical"]); n1 = norm(ins[1]["canonical"]) + if not (n0.endswith("*") and n1.endswith("*")): return None + sc = reg_scope(f["name"]) + if sc is None or sc[0] != "types": return None + if b0 == "Temporal" and b1 in BOX_MARSH: return ("tb_r:" + b1, sc[1]) # (Temporal, Box) + if b1 == "Temporal" and b0 in BOX_MARSH: return ("tb_l:" + b0, sc[1]) # (Box, Temporal) + return None + +def emit_temporal_box(f, kind): + name = f["name"]; side, box = kind.split(":"); blobto = BOX_MARSH[box][0] + if side == "tb_r": # (Temporal, Box) + body = (f" Temporal *t = BlobToTemporal(a);\n {box} *bx = {blobto}(b);\n" + f" bool r = {name}(t, bx);\n free(t); free(bx);\n return r;") + else: # (Box, Temporal) + body = (f" {box} *bx = {blobto}(a);\n Temporal *t = BlobToTemporal(b);\n" + f" bool r = {name}(bx, t);\n free(bx); free(t);\n return r;") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b) {{\n{body}\n }});\n}}\n") + +# Temporal + span -> bool: topological predicates across the value (numspan) or time +# (tstzspan) dimension. numspan PAIRS to the tnumber's value type; tstzspan is fixed and +# applies to every temporal type. ALL_TEMPORAL_ACCS = the full temporal type set (core + all +# spatial subtypes via SPATIAL_ALLTYPES, so a new spatial family inherits the time-restriction +# surface atTime/minusTime/deleteTime over tstzspan/tstzset/tstzspanset). +NUMSPAN_PAIR = {"TemporalTypes::tint()": "SpanTypes::intspan()", + "TemporalTypes::tfloat()": "SpanTypes::floatspan()"} +ALL_TEMPORAL_ACCS = (["TemporalTypes::tint()", "TemporalTypes::tbigint()", "TemporalTypes::tbool()", + "TemporalTypes::tfloat()", "TemporalTypes::ttext()"] + SPATIAL_ALLTYPES) +def shape_temporal_span(f): + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "bool" and "*" not in rn: retk = "bool" + elif rb == "Temporal" and rn.endswith("*"): retk = "T" # at/minus span -> same temporal type + else: return None + b0 = base(ins[0]["canonical"]); n0 = norm(ins[0]["canonical"]) + b1 = base(ins[1]["canonical"]); n1 = norm(ins[1]["canonical"]) + if not (n0.endswith("*") and n1.endswith("*")): return None + CONT = ("Span", "Set", "SpanSet") + if b0 == "Temporal" and b1 in CONT: side, cont = "ts_r", b1 + elif b1 == "Temporal" and b0 in CONT: side, cont = "ts_l", b0 + else: return None + nm = f["name"] + flav = "tstz" if "tstz" in nm else ("num" if re.search(r'(numspan|intspan|floatspan)', nm) else None) + if flav is None: return None + if flav == "num" and cont != "Span": return None # value-pairing only built for value spans + return (side + ":" + cont + ":" + flav + ":" + retk, None) + +CONT_BLOB = {"Span": "BlobToSpan", "Set": "BlobToSet", "SpanSet": "BlobToSpanSet"} +def emit_temporal_span(f, kind): + name = f["name"]; side, cont, _flav, retk = kind.split(":"); blob = CONT_BLOB[cont] + if retk == "T": ret_c, ret_s, rett = "Temporal *r = ", "return TemporalToBlob(result, r);", "string_t" + else: ret_c, ret_s, rett = "bool r = ", "return r;", "bool" + if side == "ts_r": # (Temporal, Container) + body = (f" Temporal *t = BlobToTemporal(a);\n {cont} *cc = {blob}(b);\n" + f" {ret_c}{name}(t, cc);\n free(t); free(cc);\n {ret_s}") + else: # (Container, Temporal) + body = (f" {cont} *cc = {blob}(a);\n Temporal *t = BlobToTemporal(b);\n" + f" {ret_c}{name}(cc, t);\n free(cc); free(t);\n {ret_s}") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b) {{\n{body}\n }});\n}}\n") + +# ---- Temporal -> container conversion (timeSpan/valueSpan/tbox), sqlSignatures-DRIVEN ---- +# A unary `Temporal -> Span/SpanSet/TBox/STBox` cast (timeSpan=temporal_to_tstzspan, +# valueSpan=tnumber_to_span, tbox=tnumber_to_tbox). Registration is a PURE PROJECTION of the +# catalog sqlSignatures — each overload's (temporal arg type -> container ret type) is read +# straight from the catalog (mechanical, zero heuristic, no `flav`). The container return +# marshals via PTR_RET (SpanToBlob/TboxToBlob/...), already present. +SQL_CONTAINER_ACC = { + "tstzspan": "SpanTypes::tstzspan()", "intspan": "SpanTypes::intspan()", + "bigintspan": "SpanTypes::bigintspan()", "floatspan": "SpanTypes::floatspan()", + "datespan": "SpanTypes::datespan()", + "tstzspanset": "SpansetTypes::tstzspanset()", "intspanset": "SpansetTypes::intspanset()", + "bigintspanset": "SpansetTypes::bigintspanset()", "floatspanset": "SpansetTypes::floatspanset()", + "datespanset": "SpansetTypes::datespanset()", + "tbox": "TboxType::tbox()", "stbox": "StboxType::stbox()", +} +def shape_temporal_to_container(f): + """(Temporal) -> Span/SpanSet/TBox/STBox conversion, registered per catalog sqlSignature. + Returns (Cbase, [(arg_acc, ret_acc)...]) over the overloads whose BOTH types are registered, + or None (no sqlSignatures / unmappable / not this shape) -> the fn is left to the hand layer.""" + if supported(f) is not None: + return None + ins, out = classify(f) + if out is not None or len(ins) != 1: + return None + if base(ins[0]["canonical"]) != "Temporal" or not norm(ins[0]["canonical"]).endswith("*"): + return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb not in ("Span", "SpanSet", "TBox", "STBox") or not rn.endswith("*"): + return None + pairs = [] + for s in (f.get("sqlSignatures") or []): + if len(s["args"]) != 1: + continue + aacc = SIG_TEMPORAL_ACC.get(s["args"][0]); racc = SQL_CONTAINER_ACC.get(s.get("ret")) + if aacc and racc and (aacc, racc) not in pairs: + pairs.append((aacc, racc)) + return (rb, pairs) if pairs else None + +def emit_temporal_to_container(f, rb): + name = f["name"]; toblob = PTR_RET[rb][1] % "r" # 'SpanToBlob(result, r)' + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n {rb} *r = {name}(t);\n free(t);\n" + f" if (!r) {{ mask.SetInvalid(idx); return string_t(); }}\n" + f" return {toblob};\n }});\n}}\n") + +# Temporal x finite-subset-of-domain -> Temporal restriction, driven by the catalog sqlSignatures +# pairings (heuristic-free, no flav). Covers the two-operand value restrictions whose second operand +# is a finite-subset representation of the value RANGE: atValues/minusValues (Set-of-T) and +# atTbox/minusTbox (TBox = the joint value x time box for numbers). Each generic MEOS fn +# (temporal_at_values, tnumber_at_tbox, ...) carries explicit [temporal-type, container-type] +# overloads; register one per pairing whose BOTH accessors are registered (cbufferset/geomset are +# skipped until their Duck set type lands). Complements shape_temporal_span, which owns the tstz time +# restrictions (atTime) and the numspan value restrictions via the name heuristic; this handles what +# it does not. The 3-operand box restrictions (atStbox with a border bool) are a separate shape. +# Marshalling map extends CONT_BLOB with the box types (BlobToTbox/BlobToStbox already emitted). +RESTRICT_CONT_BLOB = {**CONT_BLOB, "TBox": "BlobToTbox", "STBox": "BlobToStbox"} +FINITE_SUBSET_ACC = {**SET_TYPES, **SQL_CONTAINER_ACC} +def shape_temporal_restrict_sig(f): + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + if base(ins[0]["canonical"]) != "Temporal" or not norm(ins[0]["canonical"]).endswith("*"): return None + cont = base(ins[1]["canonical"]) + if cont not in RESTRICT_CONT_BLOB or not norm(ins[1]["canonical"]).endswith("*"): return None + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb != "Temporal" or not rn.endswith("*"): return None + pairs = [] + for s in (f.get("sqlSignatures") or []): + if len(s.get("args", [])) != 2: continue + aacc = SIG_TEMPORAL_ACC.get(s["args"][0]); cacc = FINITE_SUBSET_ACC.get(s["args"][1]) + if aacc and cacc and (aacc, cacc) not in pairs: pairs.append((aacc, cacc)) + return (cont, pairs) if pairs else None + +def emit_temporal_restrict_sig(f, cont): + name = f["name"]; blob = RESTRICT_CONT_BLOB[cont] # NULL-safe: a restriction that removes all -> SQL NULL + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(a);\n {cont} *cc = {blob}(b);\n" + f" Temporal *r = {name}(t, cc);\n free(t); free(cc);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n" + f" }});\n}}\n") + +def shape_scalar_first(f): + """(by-value scalar, Temporal) — the mirror of shape_binary. Covers the scalar-first + overloads the hand registers (ever_eq_int_tint, teq_int_tint, …).""" + if supported(f) is not None: return None + ins, out = classify(f) + if out is not None or len(ins) != 2: return None + b1 = base(ins[0]["canonical"]); n1 = norm(ins[0]["canonical"]) + is_text1 = (b1 == "text" and n1.endswith("*")) # owned text* arg via MakeText + if not is_text1 and (b1 not in SCALAR_ARG or "*" in n1): return None + if base(ins[1]["canonical"]) != "Temporal" or not norm(ins[1]["canonical"]).endswith("*"): return None + if reg_scope(f["name"]) is None: return None + arg1 = ("LogicalType::VARCHAR", "string_t", "__TEXT__") if is_text1 else SCALAR_ARG[b1] + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + if rb == "Temporal" and rn.endswith("*"): return ("temporal", "MD_TEMPORAL", arg1) + if rb in BYVAL_RET and "*" not in rn: return ("scalar:" + rb, scalar_ret_duck(f), arg1) + return None + +def emit_scalar_first(f, kind, arg1): + name = f["name"]; _dt, cpp1, marsh = arg1; marsh = marsh.replace("a2", "a1") + is_text = (marsh == "__TEXT__") + pre = "text *a1t = MakeText(a1);\n " if is_text else "" + call1 = "a1t" if is_text else marsh + post = "free(a1t); " if is_text else "" + if kind == "temporal": # (scalar,Temporal) -> Temporal (NULL-safe pointer return) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls<{cpp1}, string_t, string_t>(args.data[0], args.data[1], result, args.size(),\n" + f" [&]({cpp1} a1, string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {pre}Temporal *r = {name}({call1}, t);\n {post}free(t);\n" + f" return TemporalToBlobN(result, r, mask, idx);\n }});\n}}\n") + ctype, rett, _rx = scalar_emit3(f) + inner = f"{pre}{ctype} r = {name}({call1}, t);\n {post}free(t);\n return {_rx};" + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute<{cpp1}, string_t, {rett}>(args.data[0], args.data[1], result, args.size(),\n" + f" [&]({cpp1} a1, string_t in) {{\n" + f" Temporal *t = BlobToTemporal(in);\n" + f" {inner}\n" + f" }});\n}}\n") + +# ---------------- SPAN family (additive; Set/temporal paths untouched) ---------------- +# Span is a FIXED-size struct (sizeof(Span), verified span_functions.cpp). This increment +# = the generic (Span,Span)->bool|Span surface over SpanTypes::AllTypes() (span topology / +# comparison / union-intersection-minus). Element predicates (Span,scalar) = next increment. +# Element scalar -> the Span type it implies (accessors verified lowercase, span.hpp; +# canonical names from meos_catalog.c: intspan/bigintspan/floatspan/datespan/tstzspan). +ELEM_TO_SPAN = { + "int": "SpanTypes::intspan()", "int32_t": "SpanTypes::intspan()", + "int64_t": "SpanTypes::bigintspan()", "double": "SpanTypes::floatspan()", + "DateADT": "SpanTypes::datespan()", "TimestampTz": "SpanTypes::tstzspan()", +} +SPAN_TYPES = { + "intspan": "SpanTypes::intspan()", "bigintspan": "SpanTypes::bigintspan()", + "floatspan": "SpanTypes::floatspan()", "datespan": "SpanTypes::datespan()", + "tstzspan": "SpanTypes::tstzspan()", +} +def span_reg_scope(name): + if name.startswith("span_"): return ("all", None) + for pre, acc in SPAN_TYPES.items(): + if name.startswith(pre + "_") or name == pre: return ("types", [acc]) + return None +def ret_span_type(name, arg_acc): + m = re.search(r'_to_(intspan|bigintspan|floatspan|datespan|tstzspan)$', name) + return SPAN_TYPES[m.group(1)] if m else arg_acc + +# SpanSet mirrors Span (varlena -> spanset_mem_size; SpansetTypes accessors verified +# lowercase spanset.hpp + meos_catalog.c). Same shapes -> handled by the SAME collection +# machinery (shape_coll/emit_coll) via a descriptor, so SpanSet is added without duplication. +SPANSET_TYPES = { + "intspanset": "SpansetTypes::intspanset()", "bigintspanset": "SpansetTypes::bigintspanset()", + "floatspanset": "SpansetTypes::floatspanset()", + "datespanset": "SpansetTypes::datespanset()", "tstzspanset": "SpansetTypes::tstzspanset()", +} +ELEM_TO_SPANSET = { + "int": "SpansetTypes::intspanset()", "int32_t": "SpansetTypes::intspanset()", + "int64_t": "SpansetTypes::bigintspanset()", "double": "SpansetTypes::floatspanset()", + "DateADT": "SpansetTypes::datespanset()", "TimestampTz": "SpansetTypes::tstzspanset()", +} +def spanset_reg_scope(name): + if name.startswith("spanset_"): return ("all", None) + for pre, acc in SPANSET_TYPES.items(): + if name.startswith(pre + "_") or name == pre: return ("types", [acc]) + return None +def ret_spanset_type(name, arg_acc): + m = re.search(r'_to_(intspanset|bigintspanset|floatspanset|datespanset|tstzspanset)$', name) + return SPANSET_TYPES[m.group(1)] if m else arg_acc + +# Collection-family descriptors (Span + SpanSet share ALL shape logic). +SPAN_C = dict(cbase="Span", blobto="BlobToSpan", toblob="SpanToBlob", + elem=ELEM_TO_SPAN, scope=span_reg_scope, ret=ret_span_type, + alltypes="SpanTypes::AllTypes()") +SPANSET_C = dict(cbase="SpanSet", blobto="BlobToSpanSet", toblob="SpanSetToBlob", + elem=ELEM_TO_SPANSET, scope=spanset_reg_scope, ret=ret_spanset_type, + alltypes="SpansetTypes::AllTypes()") +# Box families: SINGLE type each (no AllTypes loop, no element predicates). Fixed-size +# struct -> sizeof(STBox)/sizeof(TBox) (verified single_tile_getters.cpp). Reuse the same +# (X,X)->bool|X shape machinery via the descriptor; the loop registers the concrete accessor. +STBOX_C = dict(cbase="STBox", blobto="BlobToStbox", toblob="StboxToBlob", + elem={}, scope=None, ret=lambda n, a: a, single="StboxType::stbox()") +TBOX_C = dict(cbase="TBox", blobto="BlobToTbox", toblob="TboxToBlob", + elem={}, scope=None, ret=lambda n, a: a, single="TboxType::tbox()") +def shape_span(f, C=SPAN_C): + if supported(f) is not None: return None + if re.search(r'_(transfn|finalfn|combinefn)$', f["name"]): return None + ins, out = classify(f) + if out is not None: return None + cb = C["cbase"] + rb = base(f["returnType"]["canonical"]); rn = norm(f["returnType"]["canonical"]) + contp = lambda p: base(p["canonical"]) == cb and norm(p["canonical"]).endswith("*") + sel = lambda p: base(p["canonical"]) if (base(p["canonical"]) in C["elem"] and "*" not in norm(p["canonical"])) else None + # unary (X)->X | scalar (lower/upper/width, ceil/floor; name-scoped; boxes have no scope) + if len(ins) == 1 and contp(ins[0]): + if C["scope"] is None or C["scope"](f["name"]) is None: return None + if rb == cb and rn.endswith("*"): return ("u_span", "LogicalType::BLOB") + if rb in BYVAL_RET and "*" not in rn: return ("u_scalar:" + rb, byval_ret_duck(rb)) + if rb == "Interval" and rn.endswith("*"): return ("u_scalar:Interval", "LogicalType::INTERVAL") + return None + if len(ins) != 2: return None + # element predicates: (X, scalar)->bool / (scalar, X)->bool (contains/left/...) + if rb == "bool" and "*" not in rn: + if contp(ins[0]) and sel(ins[1]): return ("setsc:" + sel(ins[1]), "LogicalType::BOOLEAN") + if contp(ins[1]) and sel(ins[0]): return ("scset:" + sel(ins[0]), "LogicalType::BOOLEAN") + # (X, by-value scalar) -> owned Interval (e.g. duration(spanset, bool)); scope-gated. + if (contp(ins[0]) and base(ins[1]["canonical"]) in SCALAR_ARG + and "*" not in norm(ins[1]["canonical"]) and rb == "Interval" and rn.endswith("*") + and C["scope"] is not None and C["scope"](f["name"]) is not None): + return ("u2iv:" + base(ins[1]["canonical"]), "LogicalType::INTERVAL") + # (X, scalar PARAM) -> X : a same-container return whose scalar is NOT an element + # (floatspan_round/floatspanset_round's precision integer). Name-scoped (span_round + # -> that container type), so the round=float-only base-value scoping falls out. + if (contp(ins[0]) and base(ins[1]["canonical"]) in SCALAR_ARG + and "*" not in norm(ins[1]["canonical"]) and rb == cb and rn.endswith("*") + and C["scope"] is not None and C["scope"](f["name"]) is not None): + return ("csc:" + base(ins[1]["canonical"]), "type") + # mixed container (Span, SpanSet) / (SpanSet, Span) -> bool : the span<->spanset + # positional operators (left/right/overleft/overright span_spanset|spanset_span). + # A 1-D span and its spanset order on the same axis, but the two operands are + # DIFFERENT containers, so the same-base (X,X) case below skips them. Marshal each + # operand as its own container; drive the concrete type pairs from sqlSignatures. + # Detect once under Span (cbase=="Span") so it is emitted exactly once, not per-C. + if (cb == "Span" and rb == "bool" and "*" not in rn + and norm(ins[0]["canonical"]).endswith("*") and norm(ins[1]["canonical"]).endswith("*")): + b0, b1 = base(ins[0]["canonical"]), base(ins[1]["canonical"]) + if {b0, b1} == {"Span", "SpanSet"}: + return ("b_mix:%s_%s" % (b0.lower(), b1.lower()), "LogicalType::BOOLEAN") + # generic (X,X) -> bool|X + if not (contp(ins[0]) and contp(ins[1])): return None + if rb == cb and rn.endswith("*"): return ("b_span", "type") + if rb == "bool" and "*" not in rn: return ("b_bool", "LogicalType::BOOLEAN") + return None + +def emit_span(f, kind, C=SPAN_C): + name = f["name"]; cb, bt, tb = C["cbase"], C["blobto"], C["toblob"] + if kind.startswith("b_mix:"): # (Span,SpanSet)/(SpanSet,Span) -> bool + t0, t1 = kind.split(':', 1)[1].split('_') # "span"/"spanset" in operand order + BT = {"span": "BlobToSpan", "spanset": "BlobToSpanSet"} + CT = {"span": "Span", "spanset": "SpanSet"} + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b) {{\n" + f" {CT[t0]} *x = {BT[t0]}(a);\n {CT[t1]} *y = {BT[t1]}(b);\n" + f" bool r = {name}(x, y);\n free(x); free(y);\n" + f" return r;\n }});\n}}\n") + if kind.startswith("setsc:"): # (X, scalar) -> bool + _dt, cpp2, marsh = SCALAR_ARG[kind.split(':')[1]] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, {cpp2} a2) {{\n" + f" {cb} *s = {bt}(a);\n bool r = {name}(s, {marsh});\n free(s);\n" + f" return r;\n }});\n}}\n") + if kind.startswith("scset:"): # (scalar, X) -> bool + _dt, cpp1, marsh = SCALAR_ARG[kind.split(':')[1]]; marsh = marsh.replace("a2", "a1") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute<{cpp1}, string_t, bool>(args.data[0], args.data[1], result, args.size(),\n" + f" [&]({cpp1} a1, string_t b) {{\n" + f" {cb} *s = {bt}(b);\n bool r = {name}({marsh}, s);\n free(s);\n" + f" return r;\n }});\n}}\n") + if kind == "u_span": # (X) -> X (pointer return; MEOS NULL = empty -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + f" [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" {cb} *s = {bt}(in);\n {cb} *r = {name}(s);\n free(s);\n" + f" if (!r) {{ mask.SetInvalid(idx); return string_t(); }}\n" + f" return {tb}(result, r);\n }});\n}}\n") + if kind.startswith("u_scalar:"): # (X) -> scalar (by-value, time-converted, or owned Interval*) + cct, rett, rexpr = byval_ret3(kind.split(':')[1]) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" UnaryExecutor::Execute(args.data[0], result, args.size(),\n" + f" [&](string_t in) {{\n" + f" {cb} *s = {bt}(in);\n {cct} r = {name}(s);\n free(s);\n" + f" return {rexpr};\n }});\n}}\n") + if kind.startswith("u2iv:"): # (X, by-value scalar) -> owned Interval (duration(spanset,bool)) + _dt, cpp2, marsh = SCALAR_ARG[kind.split(':')[1]] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2) {{\n" + f" {cb} *s = {bt}(in);\n MeosInterval *r = {name}(s, {marsh});\n free(s);\n" + f" return TakeInterval(r);\n }});\n}}\n") + if kind.startswith("csc:"): # (X, by-value scalar param) -> X (round(floatspan, integer)) + _dt, cpp2, marsh = SCALAR_ARG[kind.split(':')[1]] + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t in, {cpp2} a2, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" {cb} *s = {bt}(in);\n {cb} *r = {name}(s, {marsh});\n free(s);\n" + f" if (!r) {{ mask.SetInvalid(idx); return string_t(); }}\n" + f" return {tb}(result, r);\n }});\n}}\n") + if kind == "b_span": # (X,X) -> X (pointer return; MEOS NULL = empty -> SQL NULL) + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b, ValidityMask &mask, idx_t idx) -> string_t {{\n" + f" {cb} *s1 = {bt}(a);\n {cb} *s2 = {bt}(b);\n" + f" {cb} *r = {name}(s1, s2);\n free(s1); free(s2);\n" + f" if (!r) {{ mask.SetInvalid(idx); return string_t(); }}\n" + f" return {tb}(result, r);\n }});\n}}\n") + return (f"static void Gen_{name}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + f" EnsureMeosThreadInitialized();\n" + f" BinaryExecutor::Execute(args.data[0], args.data[1], result, args.size(),\n" + f" [&](string_t a, string_t b) {{\n" + f" {cb} *s1 = {bt}(a);\n {cb} *s2 = {bt}(b);\n" + f" bool r = {name}(s1, s2);\n free(s1); free(s2);\n return r;\n" + f" }});\n}}\n") + +# ---- canonical names only — NO coexistence prefix, ever ---- +# The North Star binding has ZERO hand-written UDFs, so there is nothing to coexist +# with: the generator OWNS every canonical name it emits, and the hand registration it +# would duplicate is DELETED in the same change (generate + delete-hand, suite-proved). +# There is no g_ transition prefix — a generated function IS the binding's function. +# RETIRED_GROUPS lists @ingroup families whose hand registrations are fully deleted, so +# the retire-safety check below verifies the generator covers every @sqlfn of each +# (dropping none). It gates SAFETY (per-family, suite-verified), not naming; naming is +# always the canonical @sqlfn. +RETIRED_GROUPS = {"meos_temporal_analytics_similarity", "meos_temporal_comp_temp", + "meos_geo_rel_ever", "meos_geo_rel_temp", + "meos_geo_bbox_topo", + "meos_temporal_math", "meos_temporal_comp_ever", + # Temporal conversions: the tnumber temporal->temporal casts (tint/tbigint/ + # tfloat) come from shape_emittable; timeSpan/valueSpan/tbox come from + # shape_temporal_to_container (sqlSignatures-driven). Retire the group as one + # wave once every @sqlfn is generated. + "meos_temporal_conversion", + # The temporal value-comparison surface (eEq/aEq/eNe/aNe + tEq/tNe) + # for every spatial family is generated from the same comp shape as the + # base temporal_comp_* groups (geo×T, T×geo literal regs + the T×T + # AllTypes loop that includes tgeometry/tgeography). Retire the whole + # surface as one wave so the safety ledger fails the build if a future + # catalog change ever drops a family's comparison coverage. + "meos_geo_comp_ever", "meos_geo_comp_temp", + "meos_cbuffer_comp_ever", "meos_cbuffer_comp_temp", + "meos_h3_comp_ever", "meos_h3_comp_temp", + "meos_npoint_comp_ever", "meos_npoint_comp_temp", + "meos_pose_comp_ever", "meos_pose_comp_temp", + "meos_rgeo_comp_ever", "meos_rgeo_comp_temp", + "meos_json_comp_ever", "meos_json_comp_temp", + # Set/span/spanset relative-position operators (left/right/before/after + + # over*, value and time axes) — generated from the span/set shapes incl the + # mixed span<->spanset case; the hand span_left/set_left + operator regs are + # deleted in the same wave. + "meos_setspan_pos", + # Set/span/spanset topological operators (contains/contained/overlaps/ + # adjacent + @>/<@/&&/-|-) — bare names + operators from the span/set shapes, + # both argument orders incl the symmetric adjacent(value, span); the hand + # set_contains/span_contains snake + operator regs are deleted. + "meos_setspan_topo", + # Temporal bounding-box topological operators (contains/contained/ + # overlaps/same/adjacent + @>/<@/&&/~=/-|-) for temporal × temporal, + # temporal × tstzspan, and tnumber × {numspan, tbox} — generated from + # the box/span shapes; the hand temporal_* snake aliases and the mixed + # cross-product operator regs in temporal.cpp are deleted. + "meos_temporal_bbox_topo"} +# @sqlfn names in a RETIRED group that the generator legitimately does NOT emit and that the +# hand keeps on purpose (a documented generator-shape gap, NOT a silent drop). Anything else +# uncovered in a retired group is a build-FATAL retire-safety error (see the validation below). +# The NxN *Pairs relations (ever/always int*->LIST(STRUCT(i,j)); temporal + SpanSet*** periods) +# are now GENERATED as scalar LIST(STRUCT) UDFs via shape_tgeoarr/emit_pairs_scalar (the 'pairs' +# form), over exactly the catalog sqlSignature geo types, so they are covered by construction — +# no longer listed here. Empty: every @sqlfn of a retired group is generated. +RETIRE_UNCOVERED_OK = set() +def retired(f): + return (f.get("group") or "") in RETIRED_GROUPS +def reg_name(nm, f): + return nm # canonical always; the g_ coexistence prefix is removed for good +def reg_names(f, sqlfn, aliases): + """The SQL names a function registers under: its sqlfn, the portable bare + alias for its operator (the cross-engine RFC dialect), and the operator symbol + itself so DuckDB exposes the operator like MobilityDB. The doxygen `@`-escape on + the operator (`\\@>`) is normalized to the bare symbol (`@>`).""" + op = (f.get("sqlop") or "").replace("\\", "") + # A backing-only @sqlfn (the shared bbox-topological tag same_bbox/contains_bbox/…, + # classified in the catalog by MEOS-API) is NOT a deployed SQL name — MobilityDB exposes + # only the operator's bare portable alias + the operator. Register the public bare name, + # never the `_bbox` backing tag. (catalog SoT: sqlfnBackingOnly / publicSqlName.) + names = [] if f.get("sqlfnBackingOnly") else [sqlfn] + bare = aliases.get(op) if aliases else None + if bare and bare not in names: + names.append(bare) + # The operator symbol is registered only when DuckDB can parse it: a name + # containing '#' is rejected by the lexer in any operator position, so those + # operators are reachable only through their bare name (before/after/tEq/...). + if op and "#" not in op and op not in names: + names.append(op) + return names + +# Output organization mirrors the canonical generator family (JMEOS FunctionsGenerator / +# Spark codegen_spark_udfs.py): every emitted body + registration is bucketed by its +# doxygen @ingroup GROUP, so a function lands in the same place across tools and the +# surface is browseable by the MEOS reference-manual structure. GReg captures the group +# of every appended line WITHOUT touching the 20 per-shape append call-sites — STATE["grp"] +# is set once per emitted function at the top of each emission loop. +STATE = {"grp": "meos_ungrouped"} +class GReg: + """A list whose .append() also records the current @ingroup group (STATE['grp']).""" + def __init__(self): self.items = [] # list of (group, line) + def append(self, line): self.items.append((STATE["grp"], line)) + def by_group(self): + d = defaultdict(list) + for g, line in self.items: d[g].append(line) + return d + def __len__(self): return len(self.items) + +# ---- Temporal constructor / transform NAME FAMILY (per-sqlName over the core types) ---- +# One base-type-generic MEOS wrapper backs a per-type SQL name FAMILY: temporal_to_tinstant is +# exposed as tintInst/tbigintInst/.../ttextInst, tsequence_make as tintSeq/..., etc. The catalog +# sqlSignatures carry each overload's own `sqlName`, so the generator registers every core-type name +# from the catalog rather than the single representative. Scoped to the 5 CORE +# types (TemporalTypes::AllTypes) — the geo/cbuffer constructors live in their own family files, so +# emitting them here would double-register. This self-contained path (like the NxN `ga` path) REPLACES +# the hand loop in src/temporal/temporal.cpp; the hand loop is deleted in the same wave to avoid a +# bare-name collision. tsequenceset_make_gaps is NOT included yet (needs DuckDB->MEOS Interval +# marshalling; absent from the hand loop today, so deferring it is a pure follow-on, no regression). +CORE_CTOR_ACC = { + "tint": "TemporalTypes::tint()", "tbigint": "TemporalTypes::tbigint()", + "tbool": "TemporalTypes::tbool()", "tfloat": "TemporalTypes::tfloat()", + "ttext": "TemporalTypes::ttext()", +} +TEMPORAL_CTOR = { + "temporal_to_tinstant": "to_inst", # Inst() + "temporal_to_tsequence": "to_seq", # Seq([, text interp]) + "temporal_to_tsequenceset": "to_seqset", # SeqSet([, text interp]) + "tsequence_make": "make_seq", # Seq([][, text, bool, bool]) + "tsequenceset_make": "make_seqset", # SeqSet([]) + "tsequenceset_make_gaps": "make_gaps", # SeqSetGaps([][, interval maxt, float maxdist, text]) + "temporal_from_hexwkb": "from_hexwkb", # FromHexWKB(text) + "temporal_from_mfjson": "from_mfjson", # FromMFJSON(text) +} +def shape_temporal_ctor(f): + return TEMPORAL_CTOR.get(f["name"]) + +def ctor_arg_slot(a, acc): + """A catalog SQL arg type -> the DuckDB LogicalType slot for a constructor overload.""" + if a.endswith("[]"): return f"LogicalType::LIST({acc})" + if a == "text": return "LogicalType::VARCHAR" + if a == "boolean": return "LogicalType::BOOLEAN" + if a == "interval": return "LogicalType::INTERVAL" + if a == "float": return "LogicalType::DOUBLE" + return acc # the temporal operand itself + +# The Gen_ body per kind, transcribed from the proven hand impls +# (src/temporal/temporal_functions.cpp: Temporal_to_t*, Tsequence(set)_constructor). The transforms +# read an optional VARCHAR interp from data[1]; the array makes marshal the LIST child into a fresh +# Temporal** (ListToTemporalArr), reinterpret to TInstant**/TSequence**, call the MEOS kernel, and +# free. temptype (for the array interp default) comes from the registered result type's alias. +_CTOR_BODY = { + "to_inst": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " Temporal *t = BlobToTemporal(in);\n" + " Temporal *r = (Temporal *) temporal_to_tinstant(t);\n" + " free(t);\n" + " return TemporalToBlobN(result, r, mask, idx);\n" + " }});\n" + "}}\n", + "to_seq": None, # filled below (shares the transform template) + "to_seqset": None, + "make_seq": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " auto rc = args.size();\n" + " auto &arr = args.data[0]; arr.Flatten(rc);\n" + " auto &child = ListVector::GetEntry(arr);\n" + " child.Flatten(ListVector::GetListSize(arr));\n" + " MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str());\n" + " interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP;\n" + " bool lower_inc = true, upper_inc = true;\n" + " if (args.ColumnCount() > 1) {{ auto &c = args.data[1]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); }}\n" + " if (args.ColumnCount() > 2) {{ auto &c = args.data[2]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) lower_inc = v.GetValue(); }}\n" + " if (args.ColumnCount() > 3) {{ auto &c = args.data[3]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) upper_inc = v.GetValue(); }}\n" + " UnaryExecutor::ExecuteWithNulls(arr, result, rc,\n" + " [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " int n = 0;\n" + " const Temporal **a = ListToTemporalArr(child, le, &n);\n" + " TSequence *seq = tsequence_make((TInstant **) a, n, lower_inc, upper_inc, interp, true);\n" + " string_t out = TemporalToBlobN(result, (Temporal *) seq, mask, idx);\n" + " FreeTemporalArr(a, n);\n" + " return out;\n" + " }});\n" + "}}\n", + "make_seqset": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " auto rc = args.size();\n" + " auto &arr = args.data[0]; arr.Flatten(rc);\n" + " auto &child = ListVector::GetEntry(arr);\n" + " child.Flatten(ListVector::GetListSize(arr));\n" + " UnaryExecutor::ExecuteWithNulls(arr, result, rc,\n" + " [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " int n = 0;\n" + " const Temporal **a = ListToTemporalArr(child, le, &n);\n" + " TSequenceSet *ss = tsequenceset_make((TSequence **) a, n, true);\n" + " string_t out = TemporalToBlobN(result, (Temporal *) ss, mask, idx);\n" + " FreeTemporalArr(a, n);\n" + " return out;\n" + " }});\n" + "}}\n", + # SeqSetGaps([][, interval maxt, float maxdist, text interp]): split the array of instants + # into sequences at temporal gaps > maxt and/or value gaps > maxdist. Optional args mirror the PG + # wrapper defaults (maxdist -1.0 = ignore value gaps, maxt NULL = ignore time gaps, interp default + # from temptype); the per-type arg subset (bool/text: only maxt; float: adds a text interp) comes + # from the catalog signatures, so the same body serves every callable arity. + "make_gaps": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " auto rc = args.size();\n" + " auto &arr = args.data[0]; arr.Flatten(rc);\n" + " auto &child = ListVector::GetEntry(arr);\n" + " child.Flatten(ListVector::GetListSize(arr));\n" + " MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str());\n" + " interpType interp = temptype_supports_linear(temptype) ? LINEAR : STEP;\n" + " MeosInterval maxt_val; bool has_maxt = false; double maxdist = -1.0;\n" + " if (args.ColumnCount() > 1) {{ auto &c = args.data[1]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) {{ maxt_val = IntervaltToInterval(v.GetValue()); has_maxt = true; }} }}\n" + " if (args.ColumnCount() > 2) {{ auto &c = args.data[2]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) maxdist = v.GetValue(); }}\n" + " if (args.ColumnCount() > 3) {{ auto &c = args.data[3]; c.Flatten(rc); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); }}\n" + " const MeosInterval *maxt = has_maxt ? &maxt_val : NULL;\n" + " UnaryExecutor::ExecuteWithNulls(arr, result, rc,\n" + " [&](list_entry_t le, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " int n = 0;\n" + " const Temporal **a = ListToTemporalArr(child, le, &n);\n" + " TSequenceSet *ss = tsequenceset_make_gaps((TInstant **) a, n, interp, maxt, maxdist);\n" + " string_t out = TemporalToBlobN(result, (Temporal *) ss, mask, idx);\n" + " FreeTemporalArr(a, n);\n" + " return out;\n" + " }});\n" + "}}\n", + # FromHexWKB(text): parse a hex-encoded WKB string into a temporal. The WKB is + # self-describing, so the kernel needs no temptype. + "from_hexwkb": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " Temporal *r = temporal_from_hexwkb(in.GetString().c_str());\n" + " return TemporalToBlobN(result, r, mask, idx);\n" + " }});\n" + "}}\n", + # FromMFJSON(text): parse a MF-JSON string into a temporal of the registered result type. + "from_mfjson": + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " MeosType temptype = TemporalHelpers::GetTemptypeFromAlias(result.GetType().GetAlias().c_str());\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " Temporal *r = temporal_from_mfjson(in.GetString().c_str(), temptype);\n" + " return TemporalToBlobN(result, r, mask, idx);\n" + " }});\n" + "}}\n", +} +_CTOR_TRANSFORM = ( + "static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " interpType interp = INTERP_NONE;\n" + " if (args.ColumnCount() > 1) {{ auto &c = args.data[1]; c.Flatten(args.size()); Value v = c.GetValue(0); if (!v.IsNull()) interp = interptype_from_string(v.ToString().c_str()); }}\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " Temporal *t = BlobToTemporal(in);\n" + " Temporal *r = (Temporal *) {meos}(t, interp);\n" + " free(t);\n" + " return TemporalToBlobN(result, r, mask, idx);\n" + " }});\n" + "}}\n") +def emit_temporal_ctor(f, kind): + fn = f["name"] + if kind == "to_seq": + return _CTOR_TRANSFORM.format(fn=fn, meos="temporal_to_tsequence") + if kind == "to_seqset": + return _CTOR_TRANSFORM.format(fn=fn, meos="temporal_to_tsequenceset") + return _CTOR_BODY[kind].format(fn=fn) + +# ---- Set/Span/SpanSet FromHexWKB parsers (per-element-type NAME FAMILY) ---- +# The base-type-generic MEOS wrappers set_from_hexwkb/span_from_hexwkb/spanset_from_hexwkb back a +# per-element-type SQL name family (intsetFromHexWKB, intspanFromHexWKB, ...). Same shape as the +# temporal from_hexwkb: a NUL-terminated hex string parses into the container, marshalled to a BLOB. +# The WKB is self-describing, so the kernel needs no element type. Core element types only; the +# spatial set elements (geo/cbuffer/npoint/...) are registered in their own family files once their +# Duck set type lands. +CONTAINER_FROM_HEXWKB = { + "set_from_hexwkb": "Set", + "span_from_hexwkb": "Span", + "spanset_from_hexwkb": "SpanSet", +} +CONTAINER_FROMHEX_ACC = {**SET_TYPES, + **{k: v for k, v in SQL_CONTAINER_ACC.items() if k not in ("tbox", "stbox")}} +_CFH_SERIALIZE = { + "Set": " return SetToBlobN(result, r, mask, idx);\n", + "Span": " if (!r) { mask.SetInvalid(idx); return string_t(); }\n" + " return SpanToBlob(result, r);\n", + "SpanSet": " if (!r) { mask.SetInvalid(idx); return string_t(); }\n" + " return SpanSetToBlob(result, r);\n", +} +def emit_container_from_hexwkb(f, cont): + fn = f["name"] + return ("static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " {cont} *r = {fn}(in.GetString().c_str());\n" + "{ser}" + " }});\n" + "}}\n").format(fn=fn, cont=cont, ser=_CFH_SERIALIZE[cont]) + +# ---- asHexWKB serializer (Temporal INHERITED output surface) ---- +# The mirror of the FromHexWKB input family: one base-type-generic MEOS wrapper +# (temporal_as_hexwkb) backs the SQL asHexWKB over EVERY temporal subtype via late binding — the +# Temporal "Input and Output" (023_temporal_inout.in.sql / geo/053_tpoint_inout.in.sql / +# tools/codegen/inherited/INHERITANCE_MAP.md §4). Canonical surface: a single name with an optional +# `endianenconding text DEFAULT ''` arg; asHexWKB is the BASE hex-WKB — Temporal_as_hexwkb calls +# Datum_as_hexwkb(extended=false) (mobilitydb type_out.c:296), variant = endian only, no SRID flag. +# (The extended asHexEWKB is a SEPARATE spatial wrapper Tspatial_as_hexewkb — its own follow-on.) +# This REPLACES the per-family hand asHexWKB (the geo files register it by hand) with the ONE +# inherited generation, and ADDS the base temporals (tint/tbigint/tfloat/tbool/ttext) that had no +# asHexWKB at all. The registered type set is the catalog sqlSignatures (sqlName == asHexWKB) +# intersected with the types the binding has (SIG_TEMPORAL_ACC) — subtypes whose Duck type is not +# yet wired (tjsonb/th3index/tnpoint/tpc*) auto-drop and land in their own family file later. The +# bare canonical name collides with the retired hand asHexWKB (deleted in the same wave). +OUTPUT_HEXWKB = { + "temporal_as_hexwkb": ("Temporal", "BlobToTemporal"), +} +OUTPUT_HEXWKB_ACC = {**SIG_TEMPORAL_ACC} +def emit_output_hexwkb(f, cls, blobto): + fn = f["name"] + # asHexWKB is the base variant; the optional endian text selects NDR/XDR/machine + # (wkb_variant_from_endian("") == 0). One Gen body serves both the 1-arg and 2-arg overloads. + return ("static void Gen_{fn}(DataChunk &args, ExpressionState &, Vector &result) {{\n" + " EnsureMeosThreadInitialized();\n" + " if (args.ColumnCount() > 1) {{\n" + " BinaryExecutor::ExecuteWithNulls(args.data[0], args.data[1], result, args.size(),\n" + " [&](string_t in, string_t endian, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " {cls} *x = {blobto}(in);\n" + " uint8_t variant = wkb_variant_from_endian(endian.GetString().c_str());\n" + " size_t sz = 0;\n" + " char *hex = {fn}(x, variant, &sz);\n" + " free(x);\n" + " if (!hex) {{ mask.SetInvalid(idx); return string_t(); }}\n" + " string_t out = StringVector::AddString(result, hex);\n" + " free(hex);\n" + " return out;\n" + " }});\n" + " }} else {{\n" + " UnaryExecutor::ExecuteWithNulls(args.data[0], result, args.size(),\n" + " [&](string_t in, ValidityMask &mask, idx_t idx) -> string_t {{\n" + " {cls} *x = {blobto}(in);\n" + " size_t sz = 0;\n" + " char *hex = {fn}(x, (uint8_t) 0, &sz);\n" + " free(x);\n" + " if (!hex) {{ mask.SetInvalid(idx); return string_t(); }}\n" + " string_t out = StringVector::AddString(result, hex);\n" + " free(hex);\n" + " return out;\n" + " }});\n" + " }}\n" + "}}\n").format(fn=fn, cls=cls, blobto=blobto) + +def gen_cpp(fns, out_path, declared=None, aliases=None): + bodies, generic_regs, specific_regs = GReg(), GReg(), GReg() + set_bodies, set_generic_regs, set_specific_regs = GReg(), GReg(), GReg() + span_bodies, span_generic_regs, span_specific_regs = GReg(), GReg(), GReg() + spanset_generic_regs = GReg(); box_regs = GReg() + temporal_box_bodies, temporal_box_regs = GReg(), GReg() + n_un = n_bin = n_ter = n_set = n_span = 0 + for f in fns: + if declared is not None and f["name"] not in declared: + continue # pin/ABI gate: skip catalog fns absent from the build headers + tc = shape_temporal_ctor(f) + if tc: + # Temporal constructor / transform NAME FAMILY: one Gen_ body, registered per + # core-type sqlName over each callable arity (the catalog argDefaults give the shorter + # overloads). Self-contained (own body + regs + continue), so the generic shapes below + # never also emit these — the bare names are owned here and by the retired hand loop. + STATE["grp"] = f.get("group") or "meos_ungrouped" + fn = f["name"] + bodies.append(emit_temporal_ctor(f, tc)) + for s in f.get("sqlSignatures", []): + # The registered SQL/return type is the RESULT temporal type (the parsers + # take a text/blob arg, the constructors an operand of the same type). + acc = CORE_CTOR_ACC.get(s["ret"]) + if not acc: + continue # non-core (geo/cbuffer) -> registered in its own family file + nm = s.get("sqlName", f["sqlfn"]) + argd = s.get("argDefaults") or [None] * len(s["args"]) + required = sum(1 for d in argd if d is None) + for k in range(required, len(s["args"]) + 1): + slots = ", ".join(ctor_arg_slot(s["args"][i], acc) for i in range(k)) + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{slots}}}, {acc}, Gen_{fn}));') + continue + cont = CONTAINER_FROM_HEXWKB.get(f["name"]) + if cont: + # Set/Span/SpanSet FromHexWKB NAME FAMILY: one Gen_ body, registered per core + # element-type sqlName over the single VARCHAR (hex) argument. Self-contained + # (own body + regs + continue) like the temporal constructor branch above. + STATE["grp"] = f.get("group") or "meos_ungrouped" + fn = f["name"] + bodies.append(emit_container_from_hexwkb(f, cont)) + for s in f.get("sqlSignatures", []): + acc = CONTAINER_FROMHEX_ACC.get(s["ret"]) + if not acc: + continue # spatial element (geo/cbuffer/npoint/...) -> its own family file + nm = s.get("sqlName", f["sqlfn"]) + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{LogicalType::VARCHAR}}, {acc}, Gen_{fn}));') + continue + oh = OUTPUT_HEXWKB.get(f["name"]) + if oh: + # asHexWKB (Temporal inherited output surface): one Gen_ body, registered per + # catalog sqlSignature over the input type for the 1-arg and 2-arg (endian text) + # arities. Only the base-WKB sqlName asHexWKB is emitted here (the extended asHexEWKB + # is a distinct spatial wrapper). Self-contained (own body + regs + continue); the bare + # name replaces the retired hand asHexWKB registrations deleted in the same wave. + cls, blobto = oh + STATE["grp"] = f.get("group") or "meos_ungrouped" + fn = f["name"] + bodies.append(emit_output_hexwkb(f, cls, blobto)) + for s in f.get("sqlSignatures", []): + nm = s.get("sqlName", f["sqlfn"]) + if nm != "asHexWKB": + continue # asHexEWKB = extended/spatial wrapper (Tspatial_as_hexewkb), own PR + acc = OUTPUT_HEXWKB_ACC.get(s["args"][0]) + if not acc: + continue # subtype whose Duck type isn't wired yet -> its own family file + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}}}, LogicalType::VARCHAR, Gen_{fn}));') + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}, LogicalType::VARCHAR}}, LogicalType::VARCHAR, Gen_{fn}));') + continue + u = shape_emittable(f); b = None if u else shape_binary(f); t = None if (u or b) else shape_ternary(f) + tt = None if (u or b or t) else shape_binary_tt(f) + tts = None if (u or b or t or tt) else shape_binary_tt_scalar(f) + sf = None if (u or b or t or tt or tts) else shape_scalar_first(f) + gt = None if (u or b or t or tt or tts or sf) else shape_geo_temporal(f) + ga = None if (u or b or t or tt or tts or sf or gt) else shape_tgeoarr(f) + pp = None if (u or b or t or tt or tts or sf or gt or ga) else shape_path(f) + if not u and not b and not t and not tt and not tts and not sf and not gt and not ga and not pp: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + sqlfn, fn = f["sqlfn"], f["name"] + scope, accs = reg_scope(fn) or ("types", None) + # A generic (`Temporal *`) function whose name carries no type is scoped "all" by + # reg_scope and blanket-registered over AllTypes()+geo. When the catalog declares its + # concrete overloads, register over exactly that set instead (the SoT) — dropping the + # over-registrations (minInstant on tbool/geo, tintInst on all nine). Per-type C fns + # keep their name scope (the type is in the canonical MEOS symbol, not a heuristic). + if scope == "all": + _declared = sig_declared_accs(f) + if _declared is not None: + scope, accs = "types", _declared + # Geo spatial-RELATIONSHIP predicates (group *_rel_ever / *_rel_temp) have NON-UNIFORM + # per-type support that the `_tgeo`/`_tpoint` name heuristic cannot express and over-expands: + # eTouches/eContains/eCovers -> tgeometry only (points use the trajectory-based _tpoint_geo + # for touches; are undefined for the others); eIntersects/eDisjoint -> all four geo types; + # eDwithin -> mixed; the _tgeo_tgeo T x T forms mirror this. + # The catalog sqlSignatures are the SoT for exactly which temporal types each backing is + # CREATE FUNCTION'd over -> scope every relationship backing (both the Temporal x geometry and + # the Temporal x Temporal shapes) by them. This stops the generic _tgeo_geo from shadowing the + # point types, binds the point-specific _tpoint_geo to tgeompoint, and drops the fabricated + # geodetic/cross-type overloads MEOS never declares. Gated to the relationship groups so the + # gt-shaped restriction ops (atValue/atGeometry, group meos_geo_restrict) keep their name scope. + if re.search(r'_rel_(ever|temp)$', f.get("group") or ""): + _gaccs = sig_declared_accs(f) + if _gaccs is not None: + scope, accs = "types", _gaccs + if u: + kind, dret = u; n_un += 1 + bodies.append(emit_body(f, kind)) + argsig = "{type}" if scope == "all" else None + spec_sig = "{%s}" + elif b: + kind, dret, arg2 = b; n_bin += 1 + bodies.append(emit_body_binary(f, kind, arg2)) + argsig = "{type, %s}" % arg2[0] + spec_sig = "{%%s, %s}" % arg2[0] + elif t: + kind, dret, arg2, arg3 = t; n_ter += 1 + bodies.append(emit_body_ternary(f, kind, arg2, arg3)) + argsig = "{type, %s, %s}" % (arg2[0], arg3[0]) + spec_sig = "{%%s, %s, %s}" % (arg2[0], arg3[0]) + elif tt: + kind, dret = tt; n_bin += 1 + bodies.append(emit_binary_tt(f, kind)) + argsig = "{type, type}" + spec_sig = "{%s, %s}" + elif tts: + kind, dret, arg3 = tts; n_ter += 1 + bodies.append(emit_binary_tt_scalar(f, kind, arg3)) + argsig = "{type, type, %s}" % arg3[0] + spec_sig = "{%%s, %%s, %s}" % arg3[0] + elif sf: + kind, dret, arg1 = sf; n_bin += 1 + bodies.append(emit_scalar_first(f, kind, arg1)) + argsig = "{%s, type}" % arg1[0] + spec_sig = "{%s, %%s}" % arg1[0] + elif gt: + kind, dret, geo_first, has_dbl = gt + if has_dbl: n_ter += 1 + else: n_bin += 1 + bodies.append(emit_geo_temporal(f, kind, geo_first, has_dbl)) + slots = ["GeoTypes::GEOMETRY()", "%s"] if geo_first else ["%s", "GeoTypes::GEOMETRY()"] + if has_dbl: slots.append("LogicalType::DOUBLE") + spec_sig = "{" + ", ".join(slots) + "}" # geo rels are always scope=='types' + argsig = spec_sig.replace("%s", "type") + elif ga: + # NxN array-of-temporal scalars over LIST() x LIST(), registered over exactly + # the element geo types the catalog CREATE FUNCTION's them for (sqlSignatures = SoT). + # Self-contained (own registration + continue), like the table-fn path. Two forms: + # minDistance -> DOUBLE ; the *Pairs SRFs -> LIST(STRUCT(i,j[,periods])) (UNNEST to rows). + n_bin += 1 + have = set() + for s in (f.get("sqlSignatures") or []): + for a in s.get("args", []): + bt = a[:-2] if a.endswith("[]") else a + if bt in SIG_TEMPORAL_ACC: + have.add(bt) + elems = [SIG_TEMPORAL_ACC[t] for t in SIG_TEMPORAL_ACC if t in have] + if ga[0] == "scalar_double": + bodies.append(emit_tgeoarr_scalar(f)) + for a in elems: + for nm in reg_names(f, sqlfn, aliases): + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{LogicalType::LIST({a}), LogicalType::LIST({a})}}, ' + f'LogicalType::DOUBLE, Gen_{fn}));') + else: + _pk, has_dist, has_periods = ga + bodies.append(emit_pairs_scalar(f, has_dist, has_periods)) + sfields = '{"i", LogicalType::INTEGER}, {"j", LogicalType::INTEGER}' + if has_periods: + sfields += ', {"periods", SpansetTypes::tstzspanset()}' + rett = f"LogicalType::LIST(LogicalType::STRUCT({{{sfields}}}))" + for a in elems: + slots = f"LogicalType::LIST({a}), LogicalType::LIST({a})" + if has_dist: + slots += ", LogicalType::DOUBLE" + for nm in reg_names(f, sqlfn, aliases): + specific_regs.append( + f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{slots}}}, {rett}, Gen_{fn}));') + continue + else: + # array-return-struct shape -> the canonical SETOF surface = a DuckDB TABLE function + # (registered via loader.RegisterFunction, NOT the scalar path). Over AllTypes + geo + # via the {type, type} placeholder the writer wraps in its AllTypes/geo loops. + n_bin += 1 + bodies.append(emit_path_table(f)) + for nm in reg_names(f, sqlfn, aliases): + generic_regs.append( + f' loader.RegisterFunction(TableFunction("{reg_name(nm, f)}", {{type, type}}, ' + f'PathExec_{fn}, PathBindFn_{fn}, PathInit_{fn}));') + continue + # Names to register: the native sqlfn + any portable bare-name alias the pin + # assigns to this fn's operator (catalog portableAliases is the SoT — invent + # nothing). The alias reuses the SAME backing body ([[aliases-reuse-backing]]). + names = reg_names(f, sqlfn, aliases) + if scope == "all": + rett = ret_temporal_type(fn, "type", f.get("group"), f.get("sqlReturnType")) if dret == "MD_TEMPORAL" else dret + for nm in names: + generic_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {argsig}, {rett}, Gen_{fn}));') + else: + for a in accs: + sig = spec_sig % ((a,) * spec_sig.count("%s")) # 1 or 2 accessor slots + r2 = ret_temporal_type(fn, a, f.get("group"), f.get("sqlReturnType")) if dret == "MD_TEMPORAL" else dret + for nm in names: + specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, {r2}, Gen_{fn}));') + # A (temporal, scalar-param DEFAULT)->temporal fn (round's precision integer DEFAULT 0) + # is callable at the shorter arity; emit the (temporal)->temporal overload with the + # catalog default substituted, over the same types. + if b and kind == "temporal" and dret == "MD_TEMPORAL" and trailing_arg_default(f): + dflt = sql_default_to_cpp(trailing_arg_default(f)) + subcast = "" if base(f["returnType"]["canonical"]) == "Temporal" else "(Temporal *) " + bodies.append(emit_defaulted_unary_temporal(fn, subcast, dflt)) + if scope == "all": + rett = ret_temporal_type(fn, "type", f.get("group"), f.get("sqlReturnType")) + for nm in names: + generic_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{type}}, {rett}, Gen_{fn}_d));') + else: + for a in accs: + r2 = ret_temporal_type(fn, a, f.get("group"), f.get("sqlReturnType")) + for nm in names: + specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}}}, {r2}, Gen_{fn}_d));') + # Same shorter-arity overload for a (Temporal, scalar-param DEFAULT)->SCALAR fn + # (duration(temporal[,boolean]) DEFAULT FALSE; asText/asEWKT(tspatial[,int]) DEFAULT 15): + # the 1-arg form is canonical SQL but geo-only-hand today — generate it for every type + # so a new family inherits it too. The return type is the fixed scalar dret. + if b and kind.startswith("scalar:") and trailing_arg_default(f): + dflt = sql_default_to_cpp(trailing_arg_default(f)) + bodies.append(emit_defaulted_unary_temporal_scalar(f, dflt)) + if scope == "all": + for nm in names: + generic_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{type}}, {dret}, Gen_{fn}_d));') + else: + for a in accs: + for nm in names: + specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}}}, {dret}, Gen_{fn}_d));') + # SET family — separate loop (the temporal path above is untouched). + for f in fns: + if declared is not None and f["name"] not in declared: + continue + s = shape_set(f) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + kind, dret = s + # (Set, scalar PARAM)->Set (round/setSRID/transform): the 2nd arg is a precision/ + # SRID, not a set element, so the set type comes from the catalog signature, not the + # element scalar. Skip entirely when the catalog declares only extended (non-core) + # sets -> no body emitted (else an unused static), no registration. + sp = set_scalar_param_sigs(f) if kind.startswith("setsc_set:") else None + if sp is not None and not sp: + continue + n_set += 1 + set_bodies.append(emit_set(f, kind)) + fn, sqlfn = f["name"], f["sqlfn"] + # portable bare-name alias; normalize the doxygen `@`-escape (sqlop "\@>" -> "@>"). + names = reg_names(f, sqlfn, aliases) + # element-typed predicates: accessor from the scalar element type, BOOLEAN ret. + if kind.startswith("setsc_set:"): # (Set, scalar element) -> Set (same set type) + b = kind.split(':')[1] + scd = "LogicalType::VARCHAR" if b == "text" else SCALAR_ARG[b][0] + # scalar-param: register over the catalog-declared core set types (round->floatset); + # element-add: the accessor is the element's set type (setUnion(intset)->intset). + pairs = sp if sp is not None else [(ELEM_TO_SET[b], ELEM_TO_SET[b], None)] + dflt = next((d for *_, d in pairs if d is not None), None) + for acc, rett, _d in pairs: + for nm in names: + set_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}, {scd}}}, {rett}, Gen_{fn}));') + # A SQL-optional trailing param (round's precision DEFAULT 0) is callable at the + # shorter arity; emit the (Set)->Set overload with the catalog default substituted. + if dflt is not None: + set_bodies.append(emit_defaulted_unary(fn, "BlobToSet", "SetToBlob", "Set", sql_default_to_cpp(dflt))) + for acc, rett, _d in pairs: + for nm in names: + set_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}}}, {rett}, Gen_{fn}_d));') + continue + if kind.startswith("setcsc:"): # (Set, scalar PARAM)->Set: degrees(floatset, bool) + b = kind.split(':')[1]; scd = SCALAR_ARG[b][0] + scope, accs = set_reg_scope(fn) + dflt = trailing_arg_default(f) + if dflt is not None: + set_bodies.append(emit_defaulted_unary(fn, "BlobToSet", "SetToBlob", "Set", + sql_default_to_cpp(dflt))) + acc_list = ["type"] if scope == "all" else accs + sink = set_generic_regs if scope == "all" else set_specific_regs + for a in acc_list: + for nm in names: + sink.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}, {scd}}}, {a}, Gen_{fn}));') + if dflt is not None: + sink.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}}}, {a}, Gen_{fn}_d));') + continue + if kind.startswith("setsc:") or kind.startswith("scset:"): + b = kind.split(':')[1]; acc = ELEM_TO_SET[b] + scd = "LogicalType::VARCHAR" if b == "text" else SCALAR_ARG[b][0] + sig = "{%s, %s}" % (acc, scd) if kind.startswith("setsc:") else "{%s, %s}" % (scd, acc) + for nm in names: + set_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, LogicalType::BOOLEAN, Gen_{fn}));') + continue + sc = set_reg_scope(fn) + scope, accs = sc if sc else ("all", None) # b_set/b_bool (_set_set) -> over AllTypes + nargs = len(classify(f)[0]) + argsig = "{type}" if nargs == 1 else "{type, type}" + spec_sig = "{%s}" if nargs == 1 else "{%s, %s}" + if scope == "all": + rett = ret_set_type(fn, "type") if dret == "LogicalType::BLOB" else dret + for nm in names: + set_generic_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {argsig}, {rett}, Gen_{fn}));') + else: + for a in accs: + sig = spec_sig % ((a,) * spec_sig.count("%s")) + r2 = ret_set_type(fn, a) if dret == "LogicalType::BLOB" else dret + for nm in names: + set_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, {r2}, Gen_{fn}));') + # COLLECTION families (Span + SpanSet) — ONE machinery via descriptor (shape_span/emit_span + # take C). Per-container generic list (its own AllTypes loop); specific list shared. + for C in (SPAN_C, SPANSET_C, STBOX_C, TBOX_C): + gen = {"Span": span_generic_regs, "SpanSet": spanset_generic_regs}.get(C["cbase"]) + for f in fns: + if declared is not None and f["name"] not in declared: + continue + s = shape_span(f, C) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + kind, dret = s; n_span += 1 + span_bodies.append(emit_span(f, kind, C)) + fn, sqlfn = f["name"], f["sqlfn"] + names = reg_names(f, sqlfn, aliases) + # element predicates: accessor from the scalar element type, BOOLEAN ret (type-specific). + if kind.startswith("setsc:") or kind.startswith("scset:"): + b = kind.split(':')[1]; acc = C["elem"][b]; scd = SCALAR_ARG[b][0] + sig = "{%s, %s}" % (acc, scd) if kind.startswith("setsc:") else "{%s, %s}" % (scd, acc) + for nm in names: + span_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, LogicalType::BOOLEAN, Gen_{fn}));') + continue + # mixed span<->spanset positional: typed per the catalog sqlSignatures + # (intspan x intspanset, ...); accessors from the span + spanset type maps. + if kind.startswith("b_mix:"): + _accmap = {**SPAN_TYPES, **SPANSET_TYPES} + _seen = set() + for s in (f.get("sqlSignatures") or []): + a0, a1 = _accmap.get(s["args"][0]), _accmap.get(s["args"][1]) + if not (a0 and a1): + continue + sig = "{%s, %s}" % (a0, a1) + if sig in _seen: + continue + _seen.add(sig) + for nm in names: + span_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, LogicalType::BOOLEAN, Gen_{fn}));') + continue + # unary (X)->X|scalar: name-scoped (X_*→AllTypes, X_*→accessor). + if kind == "u_span" or kind.startswith("u_scalar:"): + scope, accs = C["scope"](fn) + if scope == "all": + rett = C["ret"](fn, "type") if kind == "u_span" else dret + for nm in names: + gen.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{type}}, {rett}, Gen_{fn}));') + else: + for a in accs: + r2 = C["ret"](fn, a) if kind == "u_span" else dret + for nm in names: + span_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}}}, {r2}, Gen_{fn}));') + continue + # (X, by-value scalar)->Interval: name-scoped, 2-arg sig {acc, argtype}. + if kind.startswith("u2iv:"): + argdt = SCALAR_ARG[kind.split(':')[1]][0] + scope, accs = C["scope"](fn) + if scope == "all": + for nm in names: + gen.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{type, {argdt}}}, {dret}, Gen_{fn}));') + else: + for a in accs: + for nm in names: + span_specific_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}, {argdt}}}, {dret}, Gen_{fn}));') + continue + # (X, scalar PARAM)->X: floatspan(set)_round. Name-scoped 2-arg {X, argtype}->X; + # plus the shorter {X}->X overload when the trailing scalar has a SQL default. + if kind.startswith("csc:"): + argdt = SCALAR_ARG[kind.split(':')[1]][0] + scope, accs = C["scope"](fn) + dflt = trailing_arg_default(f) + if dflt is not None: + span_bodies.append(emit_defaulted_unary(fn, C["blobto"], C["toblob"], C["cbase"], + sql_default_to_cpp(dflt))) + acc_list = ["type"] if scope == "all" else accs + sink = gen if scope == "all" else span_specific_regs + for a in acc_list: + for nm in names: + sink.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}, {argdt}}}, {a}, Gen_{fn}));') + if dflt is not None: + sink.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{a}}}, {a}, Gen_{fn}_d));') + continue + # generic (X,X)->bool|X. + if C.get("single"): # box: single type, concrete accessor (no AllTypes loop) + acc = C["single"]; r = acc if kind == "b_span" else dret + for nm in names: + box_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}, {acc}}}, {r}, Gen_{fn}));') + else: + rett = "type" if kind == "b_span" else dret # (X,X)->X preserves the type + for nm in names: + gen.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{type, type}}, {rett}, Gen_{fn}));') + # Temporal + box (STBox/TBox) -> bool: spatiotemporal/numeric topological predicates, + # registered over the temporal accessors from reg_scope × the single box accessor. + for f in fns: + if declared is not None and f["name"] not in declared: + continue + s = shape_temporal_box(f) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + kind, accs = s; n_bin += 1 + temporal_box_bodies.append(emit_temporal_box(f, kind)) + fn, sqlfn = f["name"], f["sqlfn"] + names = reg_names(f, sqlfn, aliases) + box_acc = BOX_MARSH[kind.split(":")[1]][1] + for a in accs: + sig = "{%s, %s}" % (a, box_acc) if kind.startswith("tb_r:") else "{%s, %s}" % (box_acc, a) + for nm in names: + temporal_box_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, LogicalType::BOOLEAN, Gen_{fn}));') + # Temporal x span -> bool: numspan PAIRS to the tnumber value type (tint↔intspan, + # tfloat↔floatspan); tstzspan is fixed and registered over every temporal type. + for f in fns: + if declared is not None and f["name"] not in declared: + continue + s = shape_temporal_span(f) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + kind, _ = s; n_bin += 1 + temporal_box_bodies.append(emit_temporal_span(f, kind)) + fn, sqlfn = f["name"], f["sqlfn"]; side, cont, flav, retk = kind.split(":") + span_first = (side == "ts_l") + names = reg_names(f, sqlfn, aliases) + TSTZ_CONT = {"Span": "SpanTypes::tstzspan()", "Set": "SetTypes::tstzset()", + "SpanSet": "SpansetTypes::tstzspanset()"} + if flav == "num": # tnumber value span, paired (Span only) + pairs = [(NUMSPAN_PAIR[a], a) for a in reg_scope(fn)[1] if a in NUMSPAN_PAIR] + else: # tstz time container, fixed, over all temporal types + pairs = [(TSTZ_CONT[cont], a) for a in ALL_TEMPORAL_ACCS] + for spacc, tacc in pairs: + sig = "{%s, %s}" % (tacc, spacc) if not span_first else "{%s, %s}" % (spacc, tacc) + rett = tacc if retk == "T" else "LogicalType::BOOLEAN" # at/minus span preserves type + for nm in names: + temporal_box_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {sig}, {rett}, Gen_{fn}));') + # Temporal x finite-subset-of-range -> Temporal restriction (atValues/minusValues), + # sqlSignatures-driven. Runs only for restrictions the flav path (shape_temporal_span) did NOT + # claim (atTime), so a function is registered by exactly one path — no double-registration. + for f in fns: + if declared is not None and f["name"] not in declared: + continue + if shape_temporal_span(f) is not None: + continue + s = shape_temporal_restrict_sig(f) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + cont, pairs = s; n_bin += 1 + fn, sqlfn = f["name"], f["sqlfn"] + temporal_box_bodies.append(emit_temporal_restrict_sig(f, cont)) + names = reg_names(f, sqlfn, aliases) + for tacc, cacc in pairs: + for nm in names: + temporal_box_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{tacc}, {cacc}}}, {tacc}, Gen_{fn}));') + # Temporal -> container conversion (timeSpan/valueSpan/tbox), sqlSignatures-driven — the + # per-overload (temporal arg type -> container ret type) comes straight from the catalog + # (mechanical, no flav). Gated on retired(f): emit+register only for a group being retired + # as a coherent wave, so a not-yet-migrated hand @sqlfn (getTime/getValues/stbox/whenTrue, + # other groups) is never double-registered against its hand reg. + for f in fns: + if declared is not None and f["name"] not in declared: + continue + if not retired(f): + continue + s = shape_temporal_to_container(f) + if s is None: + continue + STATE["grp"] = f.get("group") or "meos_ungrouped" + rb, pairs = s; n_un += 1 + fn, sqlfn = f["name"], f["sqlfn"] + temporal_box_bodies.append(emit_temporal_to_container(f, rb)) + names = reg_names(f, sqlfn, aliases) + for aacc, racc in pairs: + for nm in names: + temporal_box_regs.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{aacc}}}, {racc}, Gen_{fn}));') + # Include order mirrors the hand .cpp files (meos_wrapper + common FIRST, before + # anything pulls duckdb::Interval into scope; all outside `namespace duckdb`). + src = ("// GENERATED by tools/codegen_duck_udfs.py from the MEOS-API catalog — DO NOT EDIT.\n" + '#include "meos_wrapper_simple.hpp"\n' + '#include "common.hpp"\n' + '#include "temporal/temporal.hpp"\n' + '#include "temporal/temporal_functions.hpp"\n' # TemporalHelpers::GetTemptypeFromAlias + '#include "temporal/set.hpp"\n' + '#include "temporal/span.hpp"\n' + '#include "temporal/spanset.hpp"\n' + '#include "temporal/tbox.hpp"\n' + '#include "geo/stbox.hpp"\n' + '#include "geo/tgeompoint.hpp"\n' + '#include "geo/tgeogpoint.hpp"\n' + '#include "geo/tgeometry.hpp"\n' + '#include "geo/tgeography.hpp"\n' + '#include "cbuffer/tcbuffer.hpp"\n' # CbufferTypes::cbuffer()/tcbuffer() + '#include "spatial/spatial_types.hpp"\n' # GeoTypes::GEOMETRY() (duckdb-spatial) + '#include "geo_util.hpp"\n' # GeometryToGSerialized(blob, srid) + '#include "meos_internal.h"\n' + '#include "meos_geo.h"\n' + '#include "meos_internal_geo.h"\n' + '#include "time_util.hpp"\n' + '#include "mobilityduck/meos_exec_serial.hpp"\n' + '#include "duckdb/function/scalar_function.hpp"\n' + '#include "duckdb/main/extension/extension_loader.hpp"\n' + '#include "duckdb/common/vector_operations/unary_executor.hpp"\n' + '#include "duckdb/common/vector_operations/binary_executor.hpp"\n' + '#include "duckdb/common/vector_operations/ternary_executor.hpp"\n' + '#include \n#include \n\n' + "namespace duckdb {\nnamespace {\n" + "// Self-contained blob<->Temporal marshalling (generated owns it; no hand-header dep).\n" + "inline string_t TemporalToBlob(Vector &result, Temporal *t) {\n" + " size_t sz = temporal_mem_size(t);\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)t, sz);\n" + " free(t);\n return out;\n}\n" + "// Null-aware variants: a MEOS function returning NULL (empty/undefined result,\n" + "// e.g. an intersection or restriction with no match) maps to SQL NULL via the mask.\n" + "inline string_t TemporalToBlobN(Vector &result, Temporal *t, ValidityMask &mask, idx_t idx) {\n" + " if (!t) { mask.SetInvalid(idx); return string_t(); }\n return TemporalToBlob(result, t);\n}\n" + "inline Temporal *BlobToTemporal(string_t blob) {\n" + " size_t sz = blob.GetSize();\n" + " uint8_t *copy = (uint8_t *)malloc(sz);\n" + " memcpy(copy, blob.GetData(), sz);\n" + " return reinterpret_cast(copy);\n}\n" + "// Array-of-temporal (LIST(blob)) INPUT marshalling for the NxN set-set functions\n" + "// (minDistance(tgeo[],tgeo[]) etc.). Reads a DuckDB LIST row's child BLOBs into a fresh\n" + "// Temporal** (each element malloc'd by BlobToTemporal); the caller frees via FreeTemporalArr.\n" + "inline const Temporal **ListToTemporalArr(Vector &child, list_entry_t le, int *count) {\n" + " auto data = FlatVector::GetData(child);\n" + " int n = (int) le.length;\n" + " const Temporal **arr = (const Temporal **) malloc(sizeof(Temporal *) * (n > 0 ? n : 1));\n" + " for (idx_t i = 0; i < le.length; i++) arr[i] = BlobToTemporal(data[le.offset + i]);\n" + " *count = n;\n return arr;\n}\n" + "inline void FreeTemporalArr(const Temporal **arr, int n) {\n" + " for (int i = 0; i < n; i++) free((void *) arr[i]);\n free((void *) arr);\n}\n" + "// Self-contained blob<->Set marshalling (hand binding's exact method: set_mem_size out).\n" + "inline string_t SetToBlob(Vector &result, Set *s) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)s, set_mem_size(s));\n" + " free(s);\n return out;\n}\n" + "inline string_t SetToBlobN(Vector &result, Set *s, ValidityMask &mask, idx_t idx) {\n" + " if (!s) { mask.SetInvalid(idx); return string_t(); }\n return SetToBlob(result, s);\n}\n" + "inline Set *BlobToSet(string_t blob) {\n" + " size_t sz = blob.GetSize();\n" + " uint8_t *copy = (uint8_t *)malloc(sz);\n" + " memcpy(copy, blob.GetData(), sz);\n" + " return reinterpret_cast(copy);\n}\n" + "// Self-contained blob<->Span marshalling (Span is a FIXED-size struct -> sizeof(Span)).\n" + "inline string_t SpanToBlob(Vector &result, Span *s) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)s, sizeof(Span));\n" + " free(s);\n return out;\n}\n" + "inline Span *BlobToSpan(string_t blob) {\n" + " size_t sz = blob.GetSize();\n" + " uint8_t *copy = (uint8_t *)malloc(sz);\n" + " memcpy(copy, blob.GetData(), sz);\n" + " return reinterpret_cast(copy);\n}\n" + "// Self-contained blob<->SpanSet marshalling (varlena -> spanset_mem_size out).\n" + "inline string_t SpanSetToBlob(Vector &result, SpanSet *ss) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)ss, spanset_mem_size(ss));\n" + " free(ss);\n return out;\n}\n" + "inline SpanSet *BlobToSpanSet(string_t blob) {\n" + " size_t sz = blob.GetSize();\n" + " uint8_t *copy = (uint8_t *)malloc(sz);\n" + " memcpy(copy, blob.GetData(), sz);\n" + " return reinterpret_cast(copy);\n}\n" + "// Self-contained blob<->Cbuffer marshalling. Cbuffer is a 4-byte-header varlena\n" + "// (int32 vl_len_ + point + radius) -> VARSIZE out; the stored BLOB is the raw bytes.\n" + "inline string_t CbufferToBlob(Vector &result, Cbuffer *cb) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)cb, VARSIZE(cb));\n" + " free(cb);\n return out;\n}\n" + "inline string_t CbufferToBlobN(Vector &result, Cbuffer *cb, ValidityMask &mask, idx_t idx) {\n" + " if (!cb) { mask.SetInvalid(idx); return string_t(); }\n return CbufferToBlob(result, cb);\n}\n" + "inline Cbuffer *BlobToCbuffer(string_t blob) {\n" + " size_t sz = blob.GetSize();\n" + " uint8_t *copy = (uint8_t *)malloc(sz);\n" + " memcpy(copy, blob.GetData(), sz);\n" + " return reinterpret_cast(copy);\n}\n" + "// Self-contained blob<->STBox/TBox marshalling (FIXED-size structs -> sizeof).\n" + "inline string_t StboxToBlob(Vector &result, STBox *b) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(STBox));\n" + " free(b);\n return out;\n}\n" + "inline STBox *BlobToStbox(string_t blob) {\n" + " uint8_t *copy = (uint8_t *)malloc(blob.GetSize());\n memcpy(copy, blob.GetData(), blob.GetSize());\n" + " return reinterpret_cast(copy);\n}\n" + "inline string_t TboxToBlob(Vector &result, TBox *b) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)b, sizeof(TBox));\n" + " free(b);\n return out;\n}\n" + "inline TBox *BlobToTbox(string_t blob) {\n" + " uint8_t *copy = (uint8_t *)malloc(blob.GetSize());\n memcpy(copy, blob.GetData(), blob.GetSize());\n" + " return reinterpret_cast(copy);\n}\n" + "// Build a MEOS text* varlena from a DuckDB VARCHAR (hand binding's exact method); caller frees.\n" + "inline text *MakeText(string_t s) {\n" + " size_t len = s.GetSize();\n" + " text *t = (text *)malloc(VARHDRSZ + len);\n" + " SET_VARSIZE(t, VARHDRSZ + len);\n" + " memcpy(VARDATA(t), s.GetData(), len);\n return t;\n}\n" + "// Convert an owned MEOS Interval* to a DuckDB interval_t and free it.\n" + "inline interval_t TakeInterval(MeosInterval *iv) {\n" + " interval_t out = IntervalToIntervalt(iv);\n free(iv);\n return out;\n}\n" + "// MEOS TimestampTz (PG epoch micros) -> DuckDB timestamp_tz_t.\n" + "inline timestamp_tz_t TakeTimestamp(TimestampTz r) {\n" + " timestamp_tz_t ts; ts.value = (int64_t) r; return MeosToDuckDBTimestamp(ts);\n}\n" + "// Owned MEOS text* varlena -> DuckDB VARCHAR string_t; frees the text*.\n" + "inline string_t TakeText(Vector &result, text *t) {\n" + " string_t out = StringVector::AddString(result, (const char *) VARDATA(t), VARSIZE(t) - VARHDRSZ);\n" + " free(t);\n return out;\n}\n" + "// Owned MEOS C-string (NUL-terminated, malloc'd) -> DuckDB VARCHAR; frees it.\n" + "inline string_t TakeCString(Vector &result, char *s) {\n" + " string_t out = StringVector::AddString(result, s);\n free(s);\n return out;\n}\n\n" + ) + + # ---- ARRAY-RETURN family: * + int* count -> LIST() (getValues/timestamps/ + # spans/tboxes). Standalone pass because these span Set/Temporal/SpanSet inputs and because + # supported() rejects them (the trailing int* count arg), so they are disjoint from the family + # loops above. Registration reuses each input family's scope + writer loop; the LIST child type + # is fixed per fn by the catalog element type. ---- + for f in fns: + if declared is not None and f["name"] not in declared: + continue + a = shape_array(f) + if a is None: + continue + _tag, ec, ib, accs = a + STATE["grp"] = f.get("group") or "meos_ungrouped" + fn, sqlfn = f["name"], f["sqlfn"] + names = reg_names(f, sqlfn, aliases) + if ib == "Set": + set_bodies.append(emit_array(f, ec, ib)); n_set += 1; spec_sink = set_specific_regs + else: + (span_bodies if ib == "SpanSet" else bodies).append(emit_array(f, ec, ib)) + if ib == "SpanSet": n_span += 1 + else: n_un += 1 + spec_sink = specific_regs + for acc in accs: # sig-declared canonical types; per-acc LIST type + ret = array_ret_duck(f, acc) + if ret is None: + continue + for nm in names: + spec_sink.append(f' RegisterSerializedScalarFunction(loader, ScalarFunction(' + f'"{reg_name(nm, f)}", {{{acc}}}, {ret}, Gen_{fn}));') + + # ---- bodies, sectioned by @ingroup group (one section per group) ---- + body_by_grp = defaultdict(list) + for acc in (bodies, set_bodies, span_bodies, temporal_box_bodies): + for g, b in acc.items: + body_by_grp[g].append(b) + body_section = "" + for g in sorted(body_by_grp): + body_section += "\n// ===== @ingroup %s =====\n" % g + "\n".join(body_by_grp[g]) + "\n" + + # ---- one RegisterGenerated_() per @ingroup group + a registerAll aggregator ---- + # Mirrors the canonical generators' one-unit-per-group structure (Spark GeneratedUdfs_ + # + registerAll). Each generic slot keeps its own type loop; specific/box/tbox at fn level. + tgen, tspec = generic_regs.by_group(), specific_regs.by_group() + sgen, sspec = set_generic_regs.by_group(), set_specific_regs.by_group() + spgen, spspec = span_generic_regs.by_group(), span_specific_regs.by_group() + ssgen, boxg = spanset_generic_regs.by_group(), box_regs.by_group() + tboxg = temporal_box_regs.by_group() + reg_groups = sorted(set(tgen) | set(tspec) | set(sgen) | set(sspec) | set(spgen) + | set(spspec) | set(ssgen) | set(boxg) | set(tboxg)) + def _loop(header, lines): + return (" " + header + "\n" + "\n".join(" " + l.strip() for l in lines) + + "\n }\n") + def _flat(lines): + return "".join(" " + l.strip() + "\n" for l in lines) + fn_section, aggregator = "", [] + for g in reg_groups: + fname = "RegisterGenerated_" + re.sub(r"[^A-Za-z0-9_]", "_", g) + b = "static void %s(ExtensionLoader &loader) {\n" % fname + if tgen.get(g): + b += _loop("for (auto &type : TemporalTypes::AllTypes()) {", tgen[g]) + # the generic Temporal surface registers over the spatial subtypes too (geo + + # tcbuffer + future) — a spatial family inherits every generic temporal op by being + # in SPATIAL_ALLTYPES, not via incidental BLOB-alias coercion. + b += _loop("for (auto &type : std::vector{" + ", ".join(SPATIAL_ALLTYPES) + "}) {", tgen[g]) + b += _flat(tspec.get(g, [])) + if sgen.get(g): b += _loop("for (auto &type : SetTypes::AllTypes()) {", sgen[g]) + b += _flat(sspec.get(g, [])) + if spgen.get(g): b += _loop("for (auto &type : SpanTypes::AllTypes()) {", spgen[g]) + b += _flat(spspec.get(g, [])) + if ssgen.get(g): b += _loop("for (auto &type : SpansetTypes::AllTypes()) {", ssgen[g]) + b += _flat(boxg.get(g, [])) + b += _flat(tboxg.get(g, [])) + b += "}\n" + fn_section += "\n" + b + aggregator.append(" %s(loader);" % fname) + reg_section = (fn_section + + "\nvoid RegisterGeneratedTemporalUdfs(ExtensionLoader &loader) {\n" + + "\n".join(aggregator) + "\n}\n") + + src += body_section + "} // anonymous\n" + reg_section + "\n} // namespace duckdb\n" + open(out_path, "w").write(src) + n_reg = (len(generic_regs) + len(specific_regs) + len(set_generic_regs) + + len(set_specific_regs) + len(span_generic_regs) + len(span_specific_regs) + + len(spanset_generic_regs) + len(box_regs) + len(temporal_box_regs)) + return n_un, n_bin, n_ter, n_reg, n_set, n_span + +# --------------------------------------------------------------------------- +# Collection type registration (set / span / spanset) generated from the +# catalog MeosType enum. The RegisterType / AllTypes / accessor set plus the +# alias->MeosType and Get{Child,Set,Base}Type mappings are uniform macro +# boilerplate whose ONLY per-family variation is the (base-value x container) +# grid — which the catalog enum encodes exactly. Deriving the type list from +# T_ membership makes the orthogonality mechanical: a base that +# has no span (text) simply produces no accessor, so a phantom textspan() can +# never be fabricated. The base LogicalType per base value is the same fixed +# map the hand code used. +BASE_LOGICAL = { + "int": "LogicalType::INTEGER", "bigint": "LogicalType::BIGINT", + "float": "LogicalType::DOUBLE", "text": "LogicalType::VARCHAR", + "date": "LogicalType::DATE", "tstz": "LogicalType::TIMESTAMP_TZ", +} +BASE_ORDER = ["int", "bigint", "float", "text", "date", "tstz"] +# suffix (longest first so spanset wins over span), class, mapping struct, DEFINE +# macro, and whether the family carries the spanset-only Set/Base child mappings. +TYPEREG_FAMILIES = [ + dict(suffix="spanset", cls="SpansetTypes", mapping="SpansetTypeMapping", + macro="DEFINE_SPAN_SET_TYPE", child="span", spanset_extra=True), + dict(suffix="span", cls="SpanTypes", mapping="SpanTypeMapping", + macro="DEFINE_SPAN_TYPE", child="base", spanset_extra=False), + dict(suffix="set", cls="SetTypes", mapping="SetTypeMapping", + macro="DEFINE_SET_TYPE", child="base", spanset_extra=False), +] + +def typereg_members(enum_names, suffix): + """Bases (in canonical order) for which T_ exists in the enum.""" + return [b for b in BASE_ORDER if ("T_" + (b + suffix).upper()) in enum_names] + +def emit_typereg_family(fam, enum_names): + cls, mp, suf, macro = fam["cls"], fam["mapping"], fam["suffix"], fam["macro"] + bases = typereg_members(enum_names, suf) + names = [b + suf for b in bases] # e.g. intspanset + L = [] + L.append(f"// --- {cls}: {len(names)} type(s) from the catalog MeosType enum ---") + L.append(f"#define {macro}(NAME) \\") + L.append(f" LogicalType {cls}::NAME() {{ \\") + L.append( " auto type = LogicalType(LogicalTypeId::BLOB); \\") + L.append( " type.SetAlias(#NAME); \\") + L.append( " return type; \\") + L.append( " }") + for n in names: + L.append(f"{macro}({n})") + L.append(f"#undef {macro}") + L.append("") + L.append(f"void {cls}::RegisterTypes(ExtensionLoader &loader) {{") + for n in names: + L.append(f' loader.RegisterType("{n}", {n}());') + L.append("}") + L.append("") + L.append(f"const std::vector &{cls}::AllTypes() {{") + L.append(" static std::vector types = {") + L.append(" " + ", ".join(f"{n}()" for n in names)) + L.append(" };") + L.append(" return types;") + L.append("}") + L.append("") + L.append(f"MeosType {mp}::GetMeosTypeFromAlias(const std::string &alias) {{") + L.append(" static const std::unordered_map alias_to_type = {") + L.append(" " + ", ".join(f'{{"{n}", T_{n.upper()}}}' for n in names)) + L.append(" };") + L.append(" auto it = alias_to_type.find(alias);") + L.append(" return it != alias_to_type.end() ? it->second : T_UNKNOWN;") + L.append("}") + L.append("") + # GetChildType: spanset -> the sibling span type; set/span -> the base LogicalType. + L.append(f"LogicalType {mp}::GetChildType(const LogicalType &type) {{") + L.append(" auto alias = type.ToString();") + for b, n in zip(bases, names): + rhs = f"SpanTypes::{b}span()" if fam["child"] == "span" else BASE_LOGICAL[b] + L.append(f' if (alias == "{n}") return {rhs};') + L.append(' throw NotImplementedException("GetChildType: unsupported alias: " + alias);') + L.append("}") + if fam["spanset_extra"]: + L.append("") + L.append(f"LogicalType {mp}::GetSetType(const LogicalType &type) {{") + L.append(" auto alias = type.ToString();") + for b, n in zip(bases, names): + L.append(f' if (alias == "{n}") return SetTypes::{b}set();') + L.append(' throw NotImplementedException("GetSetType: unsupported alias: " + alias);') + L.append("}") + L.append("") + L.append(f"LogicalType {mp}::GetBaseType(const LogicalType &type) {{") + L.append(" auto alias = type.ToString();") + for b, n in zip(bases, names): + L.append(f' if (alias == "{n}") return {BASE_LOGICAL[b]};') + L.append(' throw NotImplementedException("GetBaseType: unsupported alias: " + alias);') + L.append("}") + L.append("") + return "\n".join(L) + +def gen_type_registration(catalog, out_path): + enum = [e for e in catalog.get("enums", []) if e["name"] == "MeosType"][0] + enum_names = {v["name"] for v in enum["values"]} + parts = [ + "// GENERATED by tools/codegen_duck_udfs.py — do not edit by hand.", + "// Collection type registration (set / span / spanset). The type list of", + "// each family is the (base-value x container) grid the catalog MeosType", + "// enum declares, so the orthogonality is mechanical and phantom-free.", + "", + '#include "temporal/set.hpp"', + '#include "temporal/span.hpp"', + '#include "temporal/spanset.hpp"', + '#include "duckdb/main/extension/extension_loader.hpp"', + "#include ", + "", + "extern \"C\" {", + " #include ", + " #include ", + "}", + "", + "namespace duckdb {", + "", + ] + for fam in TYPEREG_FAMILIES: + parts.append(emit_typereg_family(fam, enum_names)) + parts.append("} // namespace duckdb") + open(out_path, "w").write("\n".join(parts)) + counts = {f["cls"]: len(typereg_members(enum_names, f["suffix"])) for f in TYPEREG_FAMILIES} + return counts + +def main(): + global RETIRED_GROUPS + pos = [a for a in sys.argv[1:] if not a.startswith("--")] + for fl in [a for a in sys.argv[1:] if a.startswith("--")]: + if fl.startswith("--retire="): + RETIRED_GROUPS = {x for x in fl[len("--retire="):].split(",") if x} + # (the --prefix / g_ coexistence flag is removed for good — names are always canonical) + # Default to the in-repo vendored catalog at a STABLE path (mirrors JMEOS's + # codegen/input/meos-idl.json, overwritten in place on each base refresh — no + # per-SHA filename, no PIN marker). Provenance is the vcpkg portfile REF + the + # regen commit message, never a versioned catalog copy. + _repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + cat = pos[0] if len(pos) > 0 else os.path.join(_repo_root, "tools/catalog/meos-idl.json") + out = pos[1] if len(pos) > 1 else None + d = json.load(open(cat)) + fns = d["functions"] + # struct layouts (e.g. Match {i,j}) for the array-return LIST(STRUCT) shape — from the catalog. + STRUCTS.update({s["name"]: s for s in d.get("structs", [])}) + # portable bare-name renderings: operator (@sqlop) -> bareName, straight from the + # catalog's portableAliases (itself generated from the MEOS doxygen @sqlop tags + + # the comparison dialect). The SoT; nothing invented here. + aliases = {} + for fam in (d.get("portableAliases", {}).get("families", {}) or {}).values(): + for e in fam: + aliases[e["operator"]] = e["bareName"] + emittable, reasons, by_fam = [], Counter(), defaultdict(list) + for f in fns: + why = supported(f) + if why is None: + emittable.append(f); by_fam[family(f)].append(f) + else: + reasons[why.split(":")[0]] += 1 + sqlfns = [f for f in fns if f.get("sqlfn")] + print(f"catalog: {len(fns)} fns, {len(sqlfns)} with sqlfn") + print(f"EMITTABLE (POC scalar shapes): {len(emittable)}") + print("top exclusion reasons:", dict(reasons.most_common(8))) + print(f"families: {len(by_fam)} ->", dict(sorted(((k, len(v)) for k, v in by_fam.items()), key=lambda x:-x[1])[:10])) + poc = [f for f in fns if shape_emittable(f)] + print(f"\nCOMPILABLE-POC subset (unary generic-Temporal*, full bodies): {len(poc)}") + if out: + hdr = pos[2] if len(pos) > 2 else None + declared = header_symbols(hdr) if hdr else None + if declared is not None: + print(f"pin/ABI gate: {len(declared)} fns declared in {hdr}") + nu, nb, nt, nr, ns, nsp = gen_cpp(fns, out, declared, aliases) + print(f"wrote {nu} unary + {nb} binary + {nt} ternary + {ns} set + {nsp} span UDF bodies, {nr} registrations -> {out}") + # Collection type registration (set/span/spanset) — the (base x container) + # grid straight from the catalog MeosType enum, emitted as a sibling file. + treg = os.path.join(os.path.dirname(out), "generated_type_registration.cpp") + tc = gen_type_registration(d, treg) + print(f"wrote collection type registration {tc} -> {treg}") + # Regularity invariant (build-failing): MEOS keeps locale/collation, session + # timezone, PROJ context and RNGs in thread-local storage, so every UDF body + # must run EnsureMeosThreadInitialized() before any MEOS call. Verify it for + # every emitted body so a future emit path cannot silently drop the guard. + body_section = open(out).read().split("} // anonymous")[0] + unguarded = [b.split("(")[0] for b in body_section.split("\nstatic void Gen_")[1:] + if "EnsureMeosThreadInitialized" not in b] + if unguarded: + print(f"FATAL: {len(unguarded)} generated UDF body(ies) reach MEOS without the " + f"per-thread MEOS-init guard:", file=sys.stderr) + for u in unguarded[:20]: + print(" Gen_" + u, file=sys.stderr) + sys.exit(1) + print(f"per-thread MEOS-init guard: all {nu + nb + nt + ns + nsp} generated bodies verified") + # Retire-safety guards (build-failing) — the two retire traps, read off the actual + # generated output so they cannot be reasoned-away by hand. + gentext = open(out).read() + emitted = Counter(re.findall(r'(?:Scalar|Table)Function\("([^"]+)"', gentext)) + # TRAP 1 (split name): a name emitted BOTH bare and g_-prefixed means a RETIRED group and + # a NON-retired group share it (bare here, g_ there) -> a query finds only one. The shared + # bare/operator dialect must be retired as a coherent wave (add the sibling groups). + split = sorted(n for n in emitted if not n.startswith("g_") and ("g_" + n) in emitted) + if split: + print(f"FATAL: retire trap 1 (split name) — {len(split)} name(s) emitted BOTH bare and " + f"g_-prefixed: a retired group shares them with a non-retired group. Retire the " + f"whole shared-name wave together (add the sibling @ingroup groups to " + f"RETIRED_GROUPS):", file=sys.stderr) + for n in split[:20]: + print(f" {n} (also g_{n})", file=sys.stderr) + sys.exit(1) + # TRAP 2 (uncovered): every @sqlfn of a RETIRED group must be emitted (bare) — else + # retiring it DROPS that function. A genuine, documented generator-shape gap kept by the + # hand goes in RETIRE_UNCOVERED_OK (with a reason); anything else is a real coverage gap. + retired_sqlfns = defaultdict(set) + for f in fns: + # A backing-only @sqlfn (sqlfnBackingOnly, e.g. the bbox-topological same_bbox/ + # contains_bbox tags) is NEVER a deployed SQL name — the generator emits its bare + # publicSqlName (same/~=/contains/@>/...) instead. So it cannot be dropped by a retire; + # exclude it from the coverage check (covered-by-construction, generalizes to any group). + if (f.get("group") in RETIRED_GROUPS) and f.get("sqlfn") and not f.get("sqlfnBackingOnly"): + retired_sqlfns[f["group"]].add(f["sqlfn"]) + uncovered = [(g, nm) for g, nms in retired_sqlfns.items() for nm in sorted(nms) + if emitted.get(nm, 0) == 0 and nm not in RETIRE_UNCOVERED_OK] + if uncovered: + print(f"FATAL: retire trap 2 (uncovered) — {len(uncovered)} @sqlfn function(s) of a " + f"RETIRED group are NOT generated, so retiring drops them. Generate them (close " + f"the shape gap), or add to RETIRE_UNCOVERED_OK with a reason if genuinely kept " + f"by hand pending a catalog/shape fix:", file=sys.stderr) + for g, nm in uncovered[:20]: + print(f" {g}: {nm}", file=sys.stderr) + sys.exit(1) + print(f"retire-safety: {len(RETIRED_GROUPS)} retired group(s) verified " + f"(no split names, every @sqlfn generated or documented)") + # sample emitted registrations (the shape; full emit = next increment) + print("\n=== sample generated registrations (first 6) ===") + for f in emittable[:6]: + ins, out = classify(f) + argts = ", ".join(arg_type(p["canonical"])[0] for p in ins) + rt, kind = ret_type(f, out) + print(f' // {f["sqlfn"]} <- {f["name"]} ({kind})') + print(f' RegisterSerializedScalarFunction(loader, ScalarFunction("{f["sqlfn"]}", ' + f'{{{argts}}}, {rt}, Gen_{f["name"]}));') + return emittable, by_fam + +if __name__ == "__main__": + main() diff --git a/tools/inherited/README.md b/tools/inherited/README.md new file mode 100644 index 00000000..8fbe2560 --- /dev/null +++ b/tools/inherited/README.md @@ -0,0 +1,61 @@ +# Inherited-behaviour generator (DuckDB) + +DuckDB sibling of MobilityDB's `tools/codegen/inherited/`. It emits the DuckDB +scalar-function registrations that every `Temporal` subtype inherits via late +binding + lifting — the same inherited-behaviour surface PostgreSQL generates from +`topops.sql.tmpl` / `posops.sql.tmpl` / … — differing only in the emitted output +(DuckDB `RegisterSerializedScalarFunction` instead of PostgreSQL `CREATE OPERATOR`). + +> **Status: design reference, not build-wired.** The live DuckDB surface is +> generated by `tools/codegen_duck_udfs.py` from the MEOS-API catalog +> (`sqlSignatures`), which already emits these inherited registrations. This +> generator demonstrates the alternative *template-driven* approach — the exact +> "reuse the PostgreSQL generator, only the output changes" shape — and is kept +> honest by `--validate`, which proves it reproduces the live catalog-generated +> surface byte-for-byte. It is the template to follow when replicating the +> inherited surfaces to other bindings, or if the catalog shape-handlers are ever +> migrated to templates. + +## Why this exists + +Behaviours like topological (`@>` `<@` `&&` `~=` `-|-`) and positional (`<<` `>>` …) +are **uniform-marshalling**: the actual work is done by the family-agnostic +`Gen__` executors (the BLOB×BLOB→bool bridges the catalog generator +already emits, one per `(op, direction)`). The only per-family part is the *wiring* — +which family is registered against its time-dimension box (`tstzspan`), its +spatiotemporal box (`stbox`) and itself. That wiring is identical across families +modulo the type token, so it is generated from one template per behaviour rather than +handled by shape-specific code paths (which is where the per-shape gaps — e.g. the +`cmp` and box gaps — came from). + +## Layout (mirrors MobilityDB `tools/codegen/inherited/`) + +| File | Role | +|---|---| +| `manifest.yaml` | subtype matrix — each family + its DuckDB `LogicalType` factory token | +| `templates/.tmpl` | the DuckDB registration skeleton (token: `@FACTORY@`, `@TEMP@`, `@BRIEF@`) | +| `generate.py` | driver: render + emit / validate | + +## Usage + +```sh +python tools/inherited/generate.py --check # list what would be emitted +python tools/inherited/generate.py --emit # write src/generated/inherited/_registrations.inc +python tools/inherited/generate.py --validate # prove the generated wiring == what the + # catalog generator emits today (subset+superset) +``` + +`--validate` is the correctness gate: it parses the generated wiring and the +registrations the catalog generator currently emits in +`src/generated/generated_temporal_udfs.cpp` for these families/behaviours and +requires them to be **equivalent** (no missing, no extra). + +## Replication + +- **To another behaviour** (posops, compops, spatialrels): add + `templates/.tmpl` (the same skeleton, different operators/executors) and + run with `--behaviour `. Topological and positional are identical processing. +- **To another binding** (Spark, JMEOS, …): copy this directory into that binding's + generator home and replace the template body with that binding's registration + syntax. `manifest.yaml` (the subtype matrix) and `generate.py` (the driver) are + reused as-is; only the template output changes. diff --git a/tools/inherited/generate.py b/tools/inherited/generate.py new file mode 100644 index 00000000..e70cde9f --- /dev/null +++ b/tools/inherited/generate.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +"""Inherited-behaviour generator (DuckDB) for Temporal subtypes. + +DuckDB sibling of MobilityDB's tools/codegen/inherited/generate.py. It emits the +DuckDB scalar-function registrations that every Temporal subtype inherits via +late binding + lifting (topops, and — replicating the same skeleton — posops, +compops, spatialrels, ...). The registrations are pure wiring to the family-agnostic +Gen__ executors (the BLOB×BLOB→bool bridges the catalog generator +already emits), identical across families modulo the type token, so they are +generated from one template per behaviour rather than hand-registered per family. + + python tools/inherited/generate.py --check # list what would be emitted + python tools/inherited/generate.py --emit # write the registration fragment + python tools/inherited/generate.py --validate # generated wiring == what the + # catalog generator emits today +""" +from __future__ import annotations +import argparse +import pathlib +import re +import sys + +try: + import yaml # pyyaml +except ImportError: + sys.exit("pyyaml is required: pip install pyyaml") + +HERE = pathlib.Path(__file__).resolve().parent +ROOT = HERE.parents[1] +MANIFEST = HERE / "manifest.yaml" +TEMPLATES = HERE / "templates" +# The catalog generator's output that this fragment is spliced into / validated against. +GENERATED_CPP = ROOT / "src" / "generated" / "generated_temporal_udfs.cpp" + +BANNER = ( + "// GENERATED by tools/inherited/generate.py from templates/{tmpl}\n" + "// DO NOT EDIT BY HAND; edit the template + tools/inherited/manifest.yaml" + " and re-run.\n") + +# The two fixed bounding-box operands shared by every tspatial family: the +# time-dimension span and the spatiotemporal box. +FIXED_FACTORIES = {"SpanTypes::tstzspan()", "StboxType::stbox()"} + +REG_RE = re.compile( + r'ScalarFunction\("([^"]+)",\s*\{\s*([\w:]+\(\)),\s*([\w:]+\(\))\s*\},' + r'\s*LogicalType::BOOLEAN,\s*(Gen_\w+)\)') + + +def render(behaviour: str, sub: dict) -> str: + tmpl = (TEMPLATES / f"{behaviour}.tmpl").read_text() + return (tmpl.replace("@FACTORY@", sub["factory"]) + .replace("@TEMP@", sub["temp"]) + .replace("@BRIEF@", sub["brief"])) + + +def render_all(behaviour: str, subs: list) -> str: + return "\n".join(render(behaviour, s) for s in subs) + + +def tuples(text: str) -> set: + """(op-name, arg1, arg2, executor) registration tuples parsed from `text`.""" + return set(REG_RE.findall(text)) + + +def generated_tuples(behaviour: str, subs: list) -> set: + return tuples(render_all(behaviour, subs)) + + +def committed_tuples(behaviour: str, subs: list) -> set: + """The topological registrations the catalog generator currently emits for our + families: keep only registrations whose executor is one of this behaviour's + shared Gen__ bridges AND both operands are a manifest family or a + fixed box operand — i.e. exactly the surface this template owns.""" + fam_factories = {s["factory"] for s in subs} + operands = fam_factories | FIXED_FACTORIES + execs = {t[3] for t in generated_tuples(behaviour, subs)} + keep = set() + for name, a1, a2, ex in tuples(GENERATED_CPP.read_text()): + if ex in execs and a1 in operands and a2 in operands: + # at least one operand must be one of OUR families (exclude box×box etc.) + if a1 in fam_factories or a2 in fam_factories: + keep.add((name, a1, a2, ex)) + return keep + + +def main() -> int: + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--check", action="store_true", help="list what would be emitted") + ap.add_argument("--emit", action="store_true", + help="write the registration fragment to src/generated/inherited/") + ap.add_argument("--validate", action="store_true", + help="generated wiring == what the catalog generator emits today") + ap.add_argument("--behaviour", default="topops", help="behaviour to generate") + args = ap.parse_args() + + mf = yaml.safe_load(MANIFEST.read_text()) + subs = [s for s in mf["subtypes"] if s.get("category") == "tspatial"] + beh = args.behaviour + + if args.validate: + gen = generated_tuples(beh, subs) + cur = committed_tuples(beh, subs) + missing = sorted(gen - cur) # template would emit, catalog does not + extra = sorted(cur - gen) # catalog emits, template would not + print(f"[{beh}] families={len(subs)} " + f"generated={len(gen)} committed(matched)={len(cur)}") + for m in missing: + print(f" ONLY-IN-TEMPLATE {m}") + for e in extra: + print(f" ONLY-IN-COMMITTED {e}") + ok = not missing and not extra + print("EQUIVALENT" if ok else "MISMATCH") + return 0 if ok else 1 + + body = render_all(beh, subs) + if args.check: + for s in subs: + print(f"would emit {beh} wiring for {s['temp']} ({s['factory']})") + print(f"total registrations: {len(tuples(body))}") + return 0 + + if args.emit: + out = ROOT / "src" / "generated" / "inherited" / f"{beh}_registrations.inc" + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(BANNER.format(tmpl=f"{beh}.tmpl") + "\n" + body) + print(f"wrote {out.relative_to(ROOT)} ({len(tuples(body))} registrations)") + return 0 + + ap.print_help() + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/inherited/manifest.yaml b/tools/inherited/manifest.yaml new file mode 100644 index 00000000..53649f09 --- /dev/null +++ b/tools/inherited/manifest.yaml @@ -0,0 +1,45 @@ +# Inherited-behaviour generator (DuckDB) — subtype matrix. +# +# This is the DuckDB sibling of MobilityDB's tools/codegen/inherited/manifest.yaml. +# It drives the SAME inherited-behaviour skeleton (the SQL surface every Temporal +# subtype inherits via late binding + lifting), but the emitted OUTPUT is DuckDB +# scalar-function registrations instead of PostgreSQL CREATE OPERATOR statements — +# "same objective, only the output changes". +# +# Each behaviour (topops, posops, compops, spatialrels, ...) is UNIFORM-marshalling: +# the actual work is done by family-agnostic Gen__ executors (the +# BLOB×BLOB→bool bridges) that the catalog generator already emits, one per +# (op, direction). This manifest + the per-behaviour template only wire each family +# to those shared executors — which is exactly what topops.sql.tmpl does for PG. +# +# Modes (tools/inherited/generate.py): +# --check list what would be emitted +# --emit write the registration fragment +# --validate prove the generated wiring == the registrations the catalog +# generator currently emits for these families/behaviours + +# Temporal subtypes that inherit the spatial (stbox-based) behaviours. +# `factory` is the DuckDB LogicalType factory for the temporal type — NOT +# mechanically derivable from the type name (tgeometry -> TGeometryTypes::tgeometry(), +# tgeompoint -> TgeompointType::tgeompoint()), so it is carried explicitly, the +# DuckDB analogue of the PG manifest's {TEMP} token. +subtypes: + - temp: tgeompoint + factory: "TgeompointType::tgeompoint()" + brief: "temporal geometry points" + category: tspatial + + - temp: tgeogpoint + factory: "TgeogpointType::tgeogpoint()" + brief: "temporal geography points" + category: tspatial + + - temp: tgeometry + factory: "TGeometryTypes::tgeometry()" + brief: "temporal geometries" + category: tspatial + + - temp: tgeography + factory: "TGeographyTypes::tgeography()" + brief: "temporal geographies" + category: tspatial diff --git a/tools/inherited/templates/topops.tmpl b/tools/inherited/templates/topops.tmpl new file mode 100644 index 00000000..4a14ba1f --- /dev/null +++ b/tools/inherited/templates/topops.tmpl @@ -0,0 +1,70 @@ +// --------------------------------------------------------------------------- +// Topological bounding-box operators for @BRIEF@ (@TEMP@) +// +// DuckDB port of MobilityDB tools/codegen/inherited/templates/topops.sql.tmpl. +// Per operator (contains @>, contained <@, overlaps &&, same ~=, adjacent -|-), +// the temporal type is wired against its time-dimension bounding box (tstzspan, +// both directions), its spatiotemporal bounding box (stbox, both directions) and +// itself (temporal × temporal), through the shared Gen__ executors. +// Every operator is registered under both its bare name and its symbol. +// --------------------------------------------------------------------------- + +// -------- Contains -------- +RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contains_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contains_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contains", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("@>", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_contains_tspatial_tspatial)); + +// -------- Contained -------- +RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_contained_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_contained_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("contained", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("<@", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_contained_tspatial_tspatial)); + +// -------- Overlaps -------- +RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_overlaps_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("overlaps", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("&&", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_overlaps_tspatial_tspatial)); + +// -------- Same -------- +RegisterSerializedScalarFunction(loader, ScalarFunction("same", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_same_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("same", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_same_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("same", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_same_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("same", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_same_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("same", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("~=", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_same_tspatial_tspatial)); + +// -------- Adjacent -------- +RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {SpanTypes::tstzspan(), @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_tstzspan_temporal)); +RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {@FACTORY@, SpanTypes::tstzspan()}, LogicalType::BOOLEAN, Gen_adjacent_temporal_tstzspan)); +RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {StboxType::stbox(), @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_stbox_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {@FACTORY@, StboxType::stbox()}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_stbox)); +RegisterSerializedScalarFunction(loader, ScalarFunction("adjacent", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); +RegisterSerializedScalarFunction(loader, ScalarFunction("-|-", {@FACTORY@, @FACTORY@}, LogicalType::BOOLEAN, Gen_adjacent_tspatial_tspatial)); diff --git a/tools/meos-source-commit.txt b/tools/meos-source-commit.txt new file mode 100644 index 00000000..19fb6344 --- /dev/null +++ b/tools/meos-source-commit.txt @@ -0,0 +1 @@ +e6e2912d37b6c6a7b94789b0306807a464931be5 diff --git a/vcpkg_ports/h3/portfile.cmake b/vcpkg_ports/h3/portfile.cmake new file mode 100644 index 00000000..aa15e699 --- /dev/null +++ b/vcpkg_ports/h3/portfile.cmake @@ -0,0 +1,39 @@ +vcpkg_check_linkage(ONLY_STATIC_LIBRARY) + +vcpkg_from_github( + OUT_SOURCE_PATH SOURCE_PATH + REPO uber/h3 + REF v${VERSION} + SHA512 6ed93c5e69adbba9804282b5814f1617d4c930b677df4735e4d4cf10fcba813f61b6be3a125d191d375e52e3e22af7c244efb007f27ca487b34eae9e24fb6c7b + HEAD_REF master +) + +vcpkg_cmake_configure( + SOURCE_PATH ${SOURCE_PATH} + OPTIONS + -DBUILD_BENCHMARKS=OFF + -DBUILD_FUZZERS=OFF + -DBUILD_FILTERS=OFF + -DBUILD_GENERATORS=OFF + -DBUILD_TESTING=OFF + # Disable the in-tree developer tooling that H3 turns on when it finds a + # clang-tidy/clang-format binary plus its `.clang-tidy` file. Under the + # wasm32-emscripten toolchain the runner's clang-tidy runs on H3's own + # sources with `-warnings-as-errors`, so vendored H3 lint findings + # (readability-braces-around-statements, non-const globals) fail the build. + # Newer upstream vcpkg h3 ports carry these same OFF flags; MobilityDB does + # not lint upstream vendored dependencies either. + -DENABLE_DOCS=OFF + -DENABLE_FORMAT=OFF + -DENABLE_LINTING=OFF +) + +vcpkg_cmake_install() + +vcpkg_cmake_config_fixup(CONFIG_PATH lib/cmake/${PORT}) + +vcpkg_copy_pdbs() + +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/bin" "${CURRENT_PACKAGES_DIR}/debug/bin" "${CURRENT_PACKAGES_DIR}/debug/include") + +file(INSTALL "${SOURCE_PATH}/LICENSE" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright) diff --git a/vcpkg_ports/h3/vcpkg.json b/vcpkg_ports/h3/vcpkg.json new file mode 100644 index 00000000..20902c31 --- /dev/null +++ b/vcpkg_ports/h3/vcpkg.json @@ -0,0 +1,18 @@ +{ + "name": "h3", + "version-semver": "4.3.0", + "description": "A Hexagonal Hierarchical Geospatial Indexing System", + "homepage": "https://github.com/uber/h3", + "license": "Apache-2.0", + "supports": "!uwp", + "dependencies": [ + { + "name": "vcpkg-cmake", + "host": true + }, + { + "name": "vcpkg-cmake-config", + "host": true + } + ] +} diff --git a/vcpkg_ports/meos/portfile.cmake b/vcpkg_ports/meos/portfile.cmake index 2a2a5614..b64f72d6 100644 --- a/vcpkg_ports/meos/portfile.cmake +++ b/vcpkg_ports/meos/portfile.cmake @@ -1,35 +1,165 @@ +# The MobilityDB commit to build libmeos from is pinned once in +# tools/meos-source-commit.txt — the single source of truth shared with the +# catalog-derivation workflow (.github/workflows/generate.yml), so the libmeos +# the binding links and the catalog it generates against always come from the +# same commit. Mirrors the shared ecosystem provision-meos model. Bumping +# the surface is one edit there plus the SHA512 below (the tarball hash for that +# commit) and a port-version bump in vcpkg.json to force a rebuild. +file(READ "${CMAKE_CURRENT_LIST_DIR}/../../tools/meos-source-commit.txt" _MEOS_REF) +string(STRIP "${_MEOS_REF}" _MEOS_REF) + vcpkg_from_github( OUT_SOURCE_PATH SOURCE_PATH REPO MobilityDB/MobilityDB - REF f11b7443ee985dc1ffb778c325e62f0edaf255ec - SHA512 ae8589acc86016c601f9c3c157e94b35e6e8fc50d6194d26db510d51e65a6e751279a3ced258a6bb6e56a22e083993aaeab92f20b9d18d41c7a2c8c73b7dc9df + REF ${_MEOS_REF} + SHA512 94f0e8a595ac7924c1a51a7d817a8b7cc4b76355dea0cc6ed3f6d67e6d0d4c8de3dd2ab788024ec29cf71844445ddb7095080381437aca39111bd281a683508d ) -vcpkg_replace_string( - "${SOURCE_PATH}/postgres/utils/CMakeLists.txt" - "set_property(TARGET utils PROPERTY POSITION_INDEPENDENT_CODE ON)" - [=[ -set_property(TARGET utils PROPERTY POSITION_INDEPENDENT_CODE ON) -if(MEOS) - target_include_directories(utils PRIVATE "${CMAKE_SOURCE_DIR}/meos/include") +# json-c's FindJSON-C.cmake uses hardcoded system hints (/usr/lib, /usr/include) +# that miss vcpkg's installed layout. Resolve the library and include paths +# explicitly so they are pre-set as cache variables before FindJSON-C runs. +set(_meos_jsonc_lib_candidates + "${CURRENT_INSTALLED_DIR}/lib/libjson-c.so" + "${CURRENT_INSTALLED_DIR}/lib/libjson-c.a" + "${CURRENT_INSTALLED_DIR}/lib/libjson-c${CMAKE_SHARED_LIBRARY_SUFFIX}" + "${CURRENT_INSTALLED_DIR}/lib/libjson-c${CMAKE_STATIC_LIBRARY_SUFFIX}") +set(_MEOS_JSONC_LIB "") +foreach(_cand IN LISTS _meos_jsonc_lib_candidates) + if(EXISTS "${_cand}") + set(_MEOS_JSONC_LIB "${_cand}") + break() + endif() +endforeach() +if(NOT _MEOS_JSONC_LIB) + message(FATAL_ERROR "MEOS port: cannot locate vcpkg-installed libjson-c under ${CURRENT_INSTALLED_DIR}/lib") endif() -]=] +# json-c headers install under include/json-c/; FindJSON-C.cmake searches for +# json.h with PATH_SUFFIXES json-c, so pass the parent include directory. +set(_MEOS_JSONC_INC "${CURRENT_INSTALLED_DIR}/include/json-c") +if(NOT EXISTS "${_MEOS_JSONC_INC}/json.h") + message(FATAL_ERROR "MEOS port: cannot locate vcpkg-installed json.h under ${CURRENT_INSTALLED_DIR}/include/json-c") +endif() + +# Upstream gap: `temporal_parse` in `meos/src/temporal/type_parser.c` routes any +# input that starts with '{' to the discrete-sequence parser, consuming the '{' as +# the outer sequence delimiter. For T_TJSONB, a bare instant like +# `{"k":1}@2000-01-01` also starts with '{' (the JSON object delimiter), so it is +# incorrectly dispatched to tdiscseq_parse which then tries to parse `"k":1}@...` +# as a temporal instant and fails with "Missing delimeter character '@'". +# +# Fix: after peeking inside the outer '{', distinguish the three cases: +# - next char is '[' or '(' → sequence set (existing behaviour) +# - next char is '{' → discrete sequence (first instant's value starts with '{') +# - anything else AND basetype == T_JSONB → JSON-object instant; restore and +# parse via tinstant_parse +# For non-T_JSONB types no observable behaviour change: their instant values never +# start with '{', so the second condition (!=T_JSONB) keeps them in tdiscseq_parse. +vcpkg_replace_string( + "${SOURCE_PATH}/meos/src/temporal/type_parser.c" + [=[ else if (**str == '{') + { + const char *bak = *str; + p_obrace(str); + p_whitespace(str); + if (**str == '[' || **str == '(') + { + *str = bak; + result = (Temporal *) tsequenceset_parse(str, temptype, interp); + } + else + { + *str = bak; + result = (Temporal *) tdiscseq_parse(str, temptype); + } + }]=] + [=[ else if (**str == '{') + { + const char *bak = *str; + p_obrace(str); + p_whitespace(str); + if (**str == '[' || **str == '(') + { + *str = bak; + result = (Temporal *) tsequenceset_parse(str, temptype, interp); + } + else if (**str == '{' || temptype_basetype(temptype) != T_JSONB) + { + /* Discrete sequence: either next token is another '{' (e.g. first + * instant's JSON-object value) or the base type never starts with '{' + * so the outer '{' is definitely the sequence delimiter. */ + *str = bak; + result = (Temporal *) tdiscseq_parse(str, temptype); + } + else + { + /* The outer '{' belongs to the base value itself (e.g. a JSON object). + * Restore and parse as a temporal instant. */ + *str = bak; + TInstant *inst = tinstant_parse(str, temptype, true); + if (! inst) + return NULL; + result = (Temporal *) inst; + } + }]=] ) +# Upstream gap: `pgtypes/libpq/pqformat.h` contains a deprecated +# static-inline helper `pq_sendint` that calls `elog()`. In the +# standalone MEOS build the pgtypes shim does not declare `elog`, and +# GCC 14 (Ubuntu 24.04 runners) treats implicit-function-declaration +# as a hard error. Replace the call with `meos_error` — both symbols +# are in scope via the postgres.h → meos_error.h chain that pqformat.c +# already includes before pulling in pqformat.h. +vcpkg_replace_string( + "${SOURCE_PATH}/pgtypes/libpq/pqformat.h" + [=[elog(ERROR, "unsupported integer size %d", b);]=] + [=[meos_error(ERROR, MEOS_ERR_INTERNAL_ERROR, "unsupported integer size %d", b);]=] +) + +# USER-APPROVED-PIN-WRITE (2026-06-23): removed the binding's own stale +# vcpkg_replace_string patches that INJECTED Datum accessors into pg_timestamp.h / +# utils/timestamp.h and re-exported add_date_int/add_timestamptz_interval into +# postgres_ext_defs.in.h. PROVEN against a clean `cmake -DMEOS=ON` install: clean +# pg_timestamp.h does not reference Int64GetDatum, the clean libmeos builds without +# these, and consumers reach add_date_int/add_timestamptz_interval by including the +# public leaf headers pg_date.h / pg_timestamp.h (see meos_wrapper_simple.hpp). +# These patches were the contamination that broke the binding's own include path. + vcpkg_cmake_configure( SOURCE_PATH "${SOURCE_PATH}" OPTIONS -DMEOS=ON + # Activate EVERY optional family so the standalone libmeos matches the full + # catalog surface the binding generates against (catalog subseteq libmeos). + # -DALL=ON FORCE-sets every family (ARROW/CBUFFER/H3/JSON/NPOINT/POINTCLOUD/ + # POSE/QUADBIN/RASTER; RGEO follows POSE via CMAKE_DEPENDENT_OPTION). Their + # external dependencies come from this port's vcpkg.json — H3 from vcpkg h3, + # RASTER from vcpkg gdal, POINTCLOUD from vcpkg libxml2 + zlib — so they build + # on every triplet (x64/arm64/osx/wasm) with no system -dev packages, the + # cross-arch equivalent of provision-meos's apt install set. POINTCLOUD builds + # its pgPointCloud core (libpc) directly from lib/*.c as a CMake static library + # with no pg_config (MobilityDB #1370), so -DALL now builds in the vcpkg model. + -DALL=ON + "-DJSON-C_LIBRARIES=${_MEOS_JSONC_LIB}" + "-DJSON-C_INCLUDE_DIRS=${_MEOS_JSONC_INC}" -DBUILD_SHARED_LIBS=ON + # Build only the MEOS library, not the MEOS C test binaries: those link + # the GEOS C++ API, which the arm64-linux vcpkg triplet does not carry. + -DBUILD_TESTING=OFF -DCMAKE_C_FLAGS="-Dsession_timezone=meos_session_timezone" -DCMAKE_CXX_FLAGS="-Dsession_timezone=meos_session_timezone" - ) -vcpkg_cmake_build(TARGET all) vcpkg_cmake_install() +# meos_tls.h is not listed in the upstream install() rules at this pin. +# It is included verbatim by the cmake-generated meos.h; copy it alongside +# the other installed headers. meos_json.h is installed automatically by +# cmake when JSON=ON (as the stripped export variant). +file(COPY "${SOURCE_PATH}/meos/include/meos_tls.h" + DESTINATION "${CURRENT_PACKAGES_DIR}/include") + file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/share/meos") file(WRITE "${CURRENT_PACKAGES_DIR}/share/meos/MEOSConfig.cmake" [=[ # Minimal imported target for MEOS diff --git a/vcpkg_ports/meos/vcpkg.json b/vcpkg_ports/meos/vcpkg.json index 22bd9c38..61bf49f2 100644 --- a/vcpkg_ports/meos/vcpkg.json +++ b/vcpkg_ports/meos/vcpkg.json @@ -1,15 +1,19 @@ { "name": "meos", "version-string": "git", - "port-version": 1, + "port-version": 11, "description": "MEOS - Mobility Engine Open Source C library (built from MobilityDB with -DMEOS=ON)", "homepage": "https://libmeos.org/", "dependencies": [ - "vcpkg-cmake", - "vcpkg-cmake-config", - "geos", - "proj", - "json-c", - "gsl" + "vcpkg-cmake", + "vcpkg-cmake-config", + "geos", + "proj", + "json-c", + "gsl", + "h3", + "gdal", + "libxml2", + "zlib" ] - } \ No newline at end of file +}