From cf7f6f8c4e9ee765a12d65517a32690175f74c3d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 30 Jul 2026 09:21:45 +0200 Subject: [PATCH] Generate the temporal pointcloud families (tpcpoint, tpcpatch) Register the tpcpoint and tpcpatch families in the UDF generator so their temporal surface is emitted from the MEOS catalog like every other family: add the tokens to REGISTERED_FAMILIES, reg_scope rules, and TO_TYPE/ SIG_TEMPORAL_ACC entries mapping the temporal types, plus a self-contained blob<->Pcpoint/Pcpatch value marshaller (both are varlena, mirroring the Cbuffer marshalling) and the pointcloud type includes. Canonicalize the hand type registration to the lowercase catalog names (meos_catalog.c: pcpoint, tpcpoint, pcpatch, tpcpatch), replacing the non-canonical uppercase TPCPOINT/TPCPATCH aliases, and add the base pcpoint/pcpatch value types as BLOB aliases mirroring cbuffer. This emits the generic temporal accessors for both types; the value accessors (startValue/atValue/getValues/constructor) wire through the Pcpoint/Pcpatch marshaller and generate once the corresponding MEOS temporal-value functions are exposed. --- src/generated/generated_temporal_udfs.cpp | 225 ++++++++++++++++++++++ src/include/meos_wrapper_simple.hpp | 7 +- src/include/pointcloud/tpcpatch.hpp | 6 +- src/include/pointcloud/tpcpoint.hpp | 6 +- src/pointcloud/tpcpatch.cpp | 216 ++++++++------------- src/pointcloud/tpcpatch_in_out.cpp | 23 ++- src/pointcloud/tpcpoint.cpp | 214 ++++++++------------ src/pointcloud/tpcpoint_in_out.cpp | 23 ++- tools/codegen_duck_udfs.py | 42 +++- vcpkg_ports/meos/vcpkg.json | 2 +- 10 files changed, 475 insertions(+), 289 deletions(-) diff --git a/src/generated/generated_temporal_udfs.cpp b/src/generated/generated_temporal_udfs.cpp index 35f098cb..56efc60e 100644 --- a/src/generated/generated_temporal_udfs.cpp +++ b/src/generated/generated_temporal_udfs.cpp @@ -16,12 +16,15 @@ #include "h3/th3index.hpp" #include "quadbin/tquadbin.hpp" #include "json/tjsonb.hpp" +#include "pointcloud/tpcpoint.hpp" +#include "pointcloud/tpcpatch.hpp" #include "spatial/spatial_types.hpp" #include "geo_util.hpp" #include "meos_internal.h" #include "meos_geo.h" #include "meos_internal_geo.h" #include "meos_json.h" +#include "meos_pointcloud.h" #include "time_util.hpp" #include "mobilityduck/meos_exec_serial.hpp" #include "duckdb/function/scalar_function.hpp" @@ -142,6 +145,38 @@ inline Jsonb *BlobToJsonb(string_t blob) { memcpy(copy, blob.GetData(), sz); return reinterpret_cast(copy); } +// Self-contained blob<->Pcpoint/Pcpatch marshalling. Both are varlena (vl_len_ +// header) -> VARSIZE out; the stored BLOB is the raw bytes (mirror Cbuffer). +inline string_t PcpointToBlob(Vector &result, Pcpoint *pt) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)pt, VARSIZE(pt)); + free(pt); + return out; +} +inline string_t PcpointToBlobN(Vector &result, Pcpoint *pt, ValidityMask &mask, idx_t idx) { + if (!pt) { mask.SetInvalid(idx); return string_t(); } + return PcpointToBlob(result, pt); +} +inline Pcpoint *BlobToPcpoint(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 PcpatchToBlob(Vector &result, Pcpatch *pa) { + string_t out = StringVector::AddStringOrBlob(result, (const char *)pa, VARSIZE(pa)); + free(pa); + return out; +} +inline string_t PcpatchToBlobN(Vector &result, Pcpatch *pa, ValidityMask &mask, idx_t idx) { + if (!pa) { mask.SetInvalid(idx); return string_t(); } + return PcpatchToBlob(result, pa); +} +inline Pcpatch *BlobToPcpatch(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)); @@ -5680,6 +5715,102 @@ static void Gen_tjsonb_minus_value(DataChunk &args, ExpressionState &, Vector &r } +// ===== @ingroup meos_pointcloud_accessor ===== +static void Gen_tpcpoint_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); + Pcpoint * r = tpcpoint_start_value(t); + free(t); + return PcpointToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpoint_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); + Pcpoint * r = tpcpoint_end_value(t); + free(t); + return PcpointToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpatch_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); + Pcpatch * r = tpcpatch_start_value(t); + free(t); + return PcpatchToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpatch_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); + Pcpatch * r = tpcpatch_end_value(t); + free(t); + return PcpatchToBlobN(result, r, mask, idx); + }); +} + + +// ===== @ingroup meos_pointcloud_restrict ===== +static void Gen_tpcpoint_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); + Pcpoint *a2p = BlobToPcpoint(a2); + Temporal *r = tpcpoint_at_value(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpoint_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); + Pcpoint *a2p = BlobToPcpoint(a2); + Temporal *r = tpcpoint_minus_value(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpatch_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); + Pcpatch *a2p = BlobToPcpatch(a2); + Temporal *r = tpcpatch_at_value(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + +static void Gen_tpcpatch_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); + Pcpatch *a2p = BlobToPcpatch(a2); + Temporal *r = tpcpatch_minus_value(t, a2p); + free(a2p); free(t); + return TemporalToBlobN(result, r, mask, idx); + }); +} + + // ===== @ingroup meos_quadbin_accessor ===== static void Gen_tquadbin_start_value(DataChunk &args, ExpressionState &, Vector &result) { EnsureMeosThreadInitialized(); @@ -16939,6 +17070,20 @@ static void RegisterGenerated_meos_json_restrict(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TJsonbTypes::tjsonb(), TJsonbTypes::jsonb()}, TJsonbTypes::tjsonb(), Gen_tjsonb_minus_value)); } +static void RegisterGenerated_meos_pointcloud_accessor(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TPcpointTypes::tpcpoint()}, TPcpointTypes::pcpoint(), Gen_tpcpoint_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TPcpointTypes::tpcpoint()}, TPcpointTypes::pcpoint(), Gen_tpcpoint_end_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::pcpatch(), Gen_tpcpatch_start_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::pcpatch(), Gen_tpcpatch_end_value)); +} + +static void RegisterGenerated_meos_pointcloud_restrict(ExtensionLoader &loader) { + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TPcpointTypes::tpcpoint(), TPcpointTypes::pcpoint()}, TPcpointTypes::tpcpoint(), Gen_tpcpoint_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TPcpointTypes::tpcpoint(), TPcpointTypes::pcpoint()}, TPcpointTypes::tpcpoint(), Gen_tpcpoint_minus_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atValue", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::pcpatch()}, TPcpatchTypes::tpcpatch(), Gen_tpcpatch_at_value)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusValue", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::pcpatch()}, TPcpatchTypes::tpcpatch(), Gen_tpcpatch_minus_value)); +} + static void RegisterGenerated_meos_quadbin_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("startValue", {QuadbinTypes::tquadbin()}, QuadbinTypes::quadbin(), Gen_tquadbin_start_value)); RegisterSerializedScalarFunction(loader, ScalarFunction("endValue", {QuadbinTypes::tquadbin()}, QuadbinTypes::quadbin(), Gen_tquadbin_end_value)); @@ -17724,6 +17869,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {H3indexTypes::th3index(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {QuadbinTypes::tquadbin(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TJsonbTypes::tjsonb(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpointTypes::tpcpoint(), LogicalType::BOOLEAN}, LogicalType::INTERVAL, Gen_temporal_duration)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpatchTypes::tpcpatch(), 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)); @@ -17737,6 +17884,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {H3indexTypes::th3index()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {QuadbinTypes::tquadbin()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TJsonbTypes::tjsonb()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpointTypes::tpcpoint()}, LogicalType::INTERVAL, Gen_temporal_duration_d)); + RegisterSerializedScalarFunction(loader, ScalarFunction("duration", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17750,6 +17899,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_end_instant)); RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_end_instant)); RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_end_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endInstant", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), 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)); @@ -17763,6 +17914,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_end_sequence)); RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_end_sequence)); RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_end_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endSequence", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), 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)); @@ -17776,6 +17929,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {H3indexTypes::th3index()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {QuadbinTypes::tquadbin()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TJsonbTypes::tjsonb()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TPcpointTypes::tpcpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("endTimestamp", {TPcpatchTypes::tpcpatch()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_end_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tint()}, LogicalType::UINTEGER, Gen_temporal_hash)); RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tbigint()}, LogicalType::UINTEGER, Gen_temporal_hash)); RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TemporalTypes::tbool()}, LogicalType::UINTEGER, Gen_temporal_hash)); @@ -17789,6 +17944,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {H3indexTypes::th3index()}, LogicalType::UINTEGER, Gen_temporal_hash)); RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {QuadbinTypes::tquadbin()}, LogicalType::UINTEGER, Gen_temporal_hash)); RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TJsonbTypes::tjsonb()}, LogicalType::UINTEGER, Gen_temporal_hash)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TPcpointTypes::tpcpoint()}, LogicalType::UINTEGER, Gen_temporal_hash)); + RegisterSerializedScalarFunction(loader, ScalarFunction("temporal_hash", {TPcpatchTypes::tpcpatch()}, LogicalType::UINTEGER, Gen_temporal_hash)); 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)); @@ -17802,6 +17959,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {H3indexTypes::th3index(), LogicalType::INTEGER}, H3indexTypes::th3index(), Gen_temporal_instant_n)); RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {QuadbinTypes::tquadbin(), LogicalType::INTEGER}, QuadbinTypes::tquadbin(), Gen_temporal_instant_n)); RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TJsonbTypes::tjsonb(), LogicalType::INTEGER}, TJsonbTypes::tjsonb(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TPcpointTypes::tpcpoint(), LogicalType::INTEGER}, TPcpointTypes::tpcpoint(), Gen_temporal_instant_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("instantN", {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER}, TPcpatchTypes::tpcpatch(), 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)); @@ -17815,6 +17974,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_interp)); RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_interp)); RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_interp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("interp", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17828,6 +17989,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {H3indexTypes::th3index()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lower_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lowerInc", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17849,6 +18012,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_instants)); RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_instants)); RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_instants)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numInstants", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17862,6 +18027,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_sequences)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numSequences", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17875,6 +18042,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_num_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("numTimestamps", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17888,6 +18057,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {H3indexTypes::th3index(), LogicalType::INTEGER}, H3indexTypes::th3index(), Gen_temporal_sequence_n)); RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {QuadbinTypes::tquadbin(), LogicalType::INTEGER}, QuadbinTypes::tquadbin(), Gen_temporal_sequence_n)); RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TJsonbTypes::tjsonb(), LogicalType::INTEGER}, TJsonbTypes::tjsonb(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TPcpointTypes::tpcpoint(), LogicalType::INTEGER}, TPcpointTypes::tpcpoint(), Gen_temporal_sequence_n)); + RegisterSerializedScalarFunction(loader, ScalarFunction("sequenceN", {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER}, TPcpatchTypes::tpcpatch(), 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)); @@ -17901,6 +18072,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_start_instant)); RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_start_instant)); RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_start_instant)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startInstant", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), 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)); @@ -17914,6 +18087,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {H3indexTypes::th3index()}, H3indexTypes::th3index(), Gen_temporal_start_sequence)); RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {QuadbinTypes::tquadbin()}, QuadbinTypes::tquadbin(), Gen_temporal_start_sequence)); RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TJsonbTypes::tjsonb()}, TJsonbTypes::tjsonb(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TPcpointTypes::tpcpoint()}, TPcpointTypes::tpcpoint(), Gen_temporal_start_sequence)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startSequence", {TPcpatchTypes::tpcpatch()}, TPcpatchTypes::tpcpatch(), 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)); @@ -17927,6 +18102,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {H3indexTypes::th3index()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {QuadbinTypes::tquadbin()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TJsonbTypes::tjsonb()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TPcpointTypes::tpcpoint()}, LogicalType::TIMESTAMP_TZ, Gen_temporal_start_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("startTimestamp", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17940,6 +18117,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_subtype)); RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_subtype)); RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_subtype)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempSubtype", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17953,6 +18132,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {H3indexTypes::th3index()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {QuadbinTypes::tquadbin()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_basetype_name)); + RegisterSerializedScalarFunction(loader, ScalarFunction("tempBasetype", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17966,6 +18147,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {H3indexTypes::th3index()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_upper_inc)); + RegisterSerializedScalarFunction(loader, ScalarFunction("upperInc", {TPcpatchTypes::tpcpatch()}, 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)); @@ -17997,6 +18180,8 @@ static void RegisterGenerated_meos_temporal_accessor(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TgeogpointType::tgeogpoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {H3indexTypes::th3index()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TJsonbTypes::tjsonb()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TPcpointTypes::tpcpoint()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {TPcpatchTypes::tpcpatch()}, LogicalType::LIST(LogicalType::TIMESTAMP_TZ), Gen_temporal_timestamps)); RegisterSerializedScalarFunction(loader, ScalarFunction("timestamps", {QuadbinTypes::tquadbin()}, 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)); @@ -19087,6 +19272,8 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {H3indexTypes::th3index(), H3indexTypes::th3index()}, LogicalType::INTEGER, Gen_temporal_cmp)); RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::INTEGER, Gen_temporal_cmp)); RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Gen_temporal_cmp)); + RegisterSerializedScalarFunction(loader, ScalarFunction("cmp", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, 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)); @@ -19113,6 +19300,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_eq)); RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_eq)); RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("eq", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_eq)); + RegisterSerializedScalarFunction(loader, ScalarFunction("=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_eq)); RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); @@ -19139,6 +19330,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_ge)); RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ge)); RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ge", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ge)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ge)); RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TemporalTypes::tbigint(), TemporalTypes::tbigint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); @@ -19165,6 +19360,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction(">", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_gt)); RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_gt)); RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("gt", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_gt)); + RegisterSerializedScalarFunction(loader, ScalarFunction(">", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, 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)); @@ -19191,6 +19390,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_le)); RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_le)); RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("le", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_le)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<=", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, 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)); @@ -19217,6 +19420,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("<", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_lt)); RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lt)); RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("lt", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_lt)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, 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)); @@ -19243,6 +19450,10 @@ static void RegisterGenerated_meos_temporal_comp_trad(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {QuadbinTypes::tquadbin(), QuadbinTypes::tquadbin()}, LogicalType::BOOLEAN, Gen_temporal_ne)); RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ne)); RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TJsonbTypes::tjsonb(), TJsonbTypes::tjsonb()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("ne", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ne)); + RegisterSerializedScalarFunction(loader, ScalarFunction("<>", {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, LogicalType::BOOLEAN, Gen_temporal_ne)); } static void RegisterGenerated_meos_temporal_constructor(ExtensionLoader &loader) { @@ -19316,6 +19527,10 @@ static void RegisterGenerated_meos_temporal_conversion(ExtensionLoader &loader) RegisterSerializedScalarFunction(loader, ScalarFunction("::", {H3indexTypes::th3index()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TJsonbTypes::tjsonb()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TJsonbTypes::tjsonb()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TPcpointTypes::tpcpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TPcpointTypes::tpcpoint()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TPcpatchTypes::tpcpatch()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); + RegisterSerializedScalarFunction(loader, ScalarFunction("::", {TPcpatchTypes::tpcpatch()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {QuadbinTypes::tquadbin()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); RegisterSerializedScalarFunction(loader, ScalarFunction("::", {QuadbinTypes::tquadbin()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); RegisterSerializedScalarFunction(loader, ScalarFunction("timeSpan", {TemporalTypes::tbool()}, SpanTypes::tstzspan(), Gen_temporal_to_tstzspan)); @@ -19370,6 +19585,10 @@ static void RegisterGenerated_meos_temporal_inout(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {H3indexTypes::th3index(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TJsonbTypes::tjsonb()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TJsonbTypes::tjsonb(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpointTypes::tpcpoint(), LogicalType::VARCHAR}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Gen_temporal_as_hexwkb)); + RegisterSerializedScalarFunction(loader, ScalarFunction("asHexWKB", {TPcpatchTypes::tpcpatch(), 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)); @@ -19554,6 +19773,8 @@ static void RegisterGenerated_meos_temporal_restrict(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {H3indexTypes::th3index(), LogicalType::TIMESTAMP_TZ}, H3indexTypes::th3index(), Gen_temporal_at_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {QuadbinTypes::tquadbin(), LogicalType::TIMESTAMP_TZ}, QuadbinTypes::tquadbin(), Gen_temporal_at_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TJsonbTypes::tjsonb(), LogicalType::TIMESTAMP_TZ}, TJsonbTypes::tjsonb(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TPcpointTypes::tpcpoint(), LogicalType::TIMESTAMP_TZ}, TPcpointTypes::tpcpoint(), Gen_temporal_at_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("atTime", {TPcpatchTypes::tpcpatch(), LogicalType::TIMESTAMP_TZ}, TPcpatchTypes::tpcpatch(), 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)); @@ -19590,6 +19811,8 @@ static void RegisterGenerated_meos_temporal_restrict(ExtensionLoader &loader) { RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {H3indexTypes::th3index(), LogicalType::TIMESTAMP_TZ}, H3indexTypes::th3index(), Gen_temporal_minus_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {QuadbinTypes::tquadbin(), LogicalType::TIMESTAMP_TZ}, QuadbinTypes::tquadbin(), Gen_temporal_minus_timestamptz)); RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TJsonbTypes::tjsonb(), LogicalType::TIMESTAMP_TZ}, TJsonbTypes::tjsonb(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TPcpointTypes::tpcpoint(), LogicalType::TIMESTAMP_TZ}, TPcpointTypes::tpcpoint(), Gen_temporal_minus_timestamptz)); + RegisterSerializedScalarFunction(loader, ScalarFunction("minusTime", {TPcpatchTypes::tpcpatch(), LogicalType::TIMESTAMP_TZ}, TPcpatchTypes::tpcpatch(), 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)); @@ -19812,6 +20035,8 @@ void RegisterGeneratedTemporalUdfs(ExtensionLoader &loader) { RegisterGenerated_meos_json_conversion(loader); RegisterGenerated_meos_json_json(loader); RegisterGenerated_meos_json_restrict(loader); + RegisterGenerated_meos_pointcloud_accessor(loader); + RegisterGenerated_meos_pointcloud_restrict(loader); RegisterGenerated_meos_quadbin_accessor(loader); RegisterGenerated_meos_quadbin_conversion(loader); RegisterGenerated_meos_setspan_accessor(loader); diff --git a/src/include/meos_wrapper_simple.hpp b/src/include/meos_wrapper_simple.hpp index a116b16f..3c66cef1 100644 --- a/src/include/meos_wrapper_simple.hpp +++ b/src/include/meos_wrapper_simple.hpp @@ -12,12 +12,15 @@ extern "C" { // 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.) + // into. meos_pointcloud.h must be wrapped here (C linkage) now that the + // pointcloud value surface (tpcpoint/tpcpatch startValue/atValue/…) generates + // and links against libmeos. (Alphabetical also keeps meos_pose.h before + // meos_rgeo.h, which depends on it.) #include #include #include #include + #include #include #include #include diff --git a/src/include/pointcloud/tpcpatch.hpp b/src/include/pointcloud/tpcpatch.hpp index 0f14a0ff..6dccfa06 100644 --- a/src/include/pointcloud/tpcpatch.hpp +++ b/src/include/pointcloud/tpcpatch.hpp @@ -11,7 +11,8 @@ namespace duckdb { struct TPcpatchTypes { - static LogicalType TPCPATCH(); + static LogicalType pcpatch(); + static LogicalType tpcpatch(); static LogicalType GEOMETRY(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); @@ -22,6 +23,9 @@ struct TPcpatchTypes { struct TpcpatchFunctions { static bool StringToTpcpatch(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static bool TpcpatchToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + // Base pcpatch value (BLOB-alias) -> VARCHAR render cast (pcpatch_hex_out), so the + // generated startValue/endValue base value renders as hex-WKB text (cbuffer sibling). + static bool Pcpatch_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); }; diff --git a/src/include/pointcloud/tpcpoint.hpp b/src/include/pointcloud/tpcpoint.hpp index 54acd200..33d8a0d4 100644 --- a/src/include/pointcloud/tpcpoint.hpp +++ b/src/include/pointcloud/tpcpoint.hpp @@ -11,7 +11,8 @@ namespace duckdb { struct TPcpointTypes { - static LogicalType TPCPOINT(); + static LogicalType pcpoint(); + static LogicalType tpcpoint(); static LogicalType GEOMETRY(); static void RegisterTypes(ExtensionLoader &loader); static void RegisterScalarFunctions(ExtensionLoader &loader); @@ -22,6 +23,9 @@ struct TPcpointTypes { struct TpcpointFunctions { static bool StringToTpcpoint(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static bool TpcpointToString(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); + // Base pcpoint value (BLOB-alias) -> VARCHAR render cast (pcpoint_hex_out), so the + // generated startValue/endValue base value renders as hex-WKB text (cbuffer sibling). + static bool Pcpoint_out_cast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); static bool WkbBlobToGeometry(Vector &source, Vector &result, idx_t count, CastParameters ¶meters); }; diff --git a/src/pointcloud/tpcpatch.cpp b/src/pointcloud/tpcpatch.cpp index e9c3d5bf..114d1683 100644 --- a/src/pointcloud/tpcpatch.cpp +++ b/src/pointcloud/tpcpatch.cpp @@ -48,9 +48,15 @@ extern "C" { namespace duckdb { -LogicalType TPcpatchTypes::TPCPATCH() { +LogicalType TPcpatchTypes::pcpatch() { auto type = LogicalType(LogicalTypeId::BLOB); - type.SetAlias("TPCPATCH"); + type.SetAlias("pcpatch"); + return type; +} + +LogicalType TPcpatchTypes::tpcpatch() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("tpcpatch"); return type; } @@ -72,7 +78,7 @@ static void Tpcpatch_constructor(DataChunk &args, ExpressionState &state, Vector // T_TPCPATCH). Temporal *tinst = temporal_in(input.c_str(), T_TPCPATCH); if (!tinst) { - throw InvalidInputException("Invalid TPCPATCH input: " + input); + throw InvalidInputException("Invalid tpcpatch input: " + input); } size_t data_size = temporal_mem_size(tinst); @@ -80,7 +86,7 @@ static void Tpcpatch_constructor(DataChunk &args, ExpressionState &state, Vector uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(tinst); - throw InvalidInputException("Failed to allocate memory for TPCPATCH data"); + throw InvalidInputException("Failed to allocate memory for tpcpatch data"); } memcpy(data_buffer, tinst, data_size); @@ -447,13 +453,13 @@ static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } Span *timespan = temporal_to_tstzspan(temp); if (!timespan) { - throw InvalidInputException("Failed to extract timespan from TPCPATCH"); + throw InvalidInputException("Failed to extract timespan from tpcpatch"); } size_t span_size = sizeof(Span); @@ -497,12 +503,12 @@ static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } TInstant *inst = temporal_as_tinstant(temp); if (!inst) { - throw InvalidInputException("Failed to convert TPCPATCH to TInstant"); + throw InvalidInputException("Failed to convert tpcpatch to TInstant"); } size_t inst_size = temporal_mem_size((Temporal*)inst); @@ -547,7 +553,7 @@ static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } std::string interp_str = interp_str_t.GetString(); @@ -597,14 +603,14 @@ static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); if (!temp1) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } std::string tgeom2 = tgeom2_str_t.GetString(); Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); if (!temp2) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } Temporal *result_temp = temporal_merge(temp1, temp2); @@ -653,7 +659,7 @@ static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } const char *subtype_str = temporal_subtype(temp); @@ -689,7 +695,7 @@ static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } @@ -722,7 +728,7 @@ static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } size_t mem_size = temporal_mem_size(temp); @@ -789,75 +795,32 @@ static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu -static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { - auto count = args.size(); - auto &input_vec = args.data[0]; +/* Temporal_start_value/Temporal_end_value retired: startValue/endValue are now + * generated (return the pcpatch base value, rendered via the pcpatch->VARCHAR cast). */ +/* Base pcpatch value (BLOB-alias) -> VARCHAR render cast, mirroring the cbuffer + * sibling's Cbuffer_out_cast. The generated startValue/endValue return the pcpatch + * base value; DuckDB renders it through this cast via the schema-free pcpatch_hex_out + * (hex-WKB text), the same form the retired hand accessors produced. */ +bool TpcpatchFunctions::Pcpatch_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ UnaryExecutor::Execute( - input_vec, result, count, - [&](string_t input_str) -> string_t { - std::string input = input_str.GetString(); - - Temporal *temp = reinterpret_cast(const_cast(input.c_str())); - - // temporal_start_value returns a freshly allocated copy of - // the pcpatch value (datum_copy), which the caller owns. - Datum start_datum = temporal_start_value(temp); - - Pcpatch *pt = reinterpret_cast(start_datum); + source, result, count, + [&](string_t blob) -> string_t { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + Pcpatch *pt = reinterpret_cast(copy); char *str = pcpatch_hex_out(pt, 15); - if (!str) { - free(pt); - throw InvalidInputException("Failed to convert pcpatch value to text"); - } - std::string output(str); - string_t stored_result = StringVector::AddString(result, output); - - free(str); free(pt); - - return stored_result; - }); - - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - - -static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { - auto count = args.size(); - auto &input_vec = args.data[0]; - - UnaryExecutor::Execute( - input_vec, result, count, - [&](string_t input_str) -> string_t { - std::string input = input_str.GetString(); - - Temporal *temp = reinterpret_cast(const_cast(input.c_str())); - - // temporal_end_value returns a freshly allocated copy of - // the pcpatch value (datum_copy), which the caller owns. - Datum end_datum = temporal_end_value(temp); - - Pcpatch *pt = reinterpret_cast(end_datum); - char *str = pcpatch_hex_out(pt, 15); - if (!str) { - free(pt); + if (!str) throw InvalidInputException("Failed to convert pcpatch value to text"); - } - std::string output(str); - string_t stored_result = StringVector::AddString(result, output); - + std::string s(str); free(str); - free(pt); - - return stored_result; + return StringVector::AddString(result, s); }); - - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } + return true; } static void Tpcpatch_pcid(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1109,12 +1072,12 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TPCPATCH data: insufficient size"); + throw InvalidInputException("Invalid tpcpatch data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TPCPATCH deserialization"); + throw InvalidInputException("Failed to allocate memory for tpcpatch deserialization"); } memcpy(data_copy, data, data_size); @@ -1122,7 +1085,7 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } TimestampTz meos_t = temp->t; @@ -1145,87 +1108,87 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tpcpatch_function = ScalarFunction( - "TPCPATCH", + "tpcpatch", {LogicalType::VARCHAR}, - TPcpatchTypes::TPCPATCH(), + TPcpatchTypes::tpcpatch(), Tpcpatch_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_function); auto tpcpatch_from_timestamp_function = ScalarFunction( - "TPCPATCH", + "tpcpatch", {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, - TPcpatchTypes::TPCPATCH(), + TPcpatchTypes::tpcpatch(), Tpcpatchinst_constructor); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_from_timestamp_function); auto tpcpatch_from_tstzspan_function = ScalarFunction( - "TPCPATCH", + "tpcpatch", {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR}, - TPcpatchTypes::TPCPATCH(), + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_from_tstzspan_function); auto tpcpatch_from_tstzspan_default = ScalarFunction( - "TPCPATCH", + "tpcpatch", {LogicalType::VARCHAR, SpanTypes::tstzspan()}, - TPcpatchTypes::TPCPATCH(), + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_from_tstzspan_default); auto tpcpatchseqarr_1param= ScalarFunction( "tpcpatchSeq", - {LogicalType::LIST(TPcpatchTypes::TPCPATCH())}, - TPcpatchTypes::TPCPATCH(), + {LogicalType::LIST(TPcpatchTypes::tpcpatch())}, + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatchseqarr_1param); auto tpcpatchseqarr_2params = ScalarFunction( "tpcpatchSeq", - {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR}, - TPcpatchTypes::TPCPATCH(), + {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR}, + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatchseqarr_2params); auto tpcpatchseqarr_3params = ScalarFunction( "tpcpatchSeq", - {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - TPcpatchTypes::TPCPATCH(), + {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatchseqarr_3params); auto tpcpatchseqarr_4params = ScalarFunction( "tpcpatchSeq", - {LogicalType::LIST(TPcpatchTypes::TPCPATCH()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - TPcpatchTypes::TPCPATCH(), + {LogicalType::LIST(TPcpatchTypes::tpcpatch()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TPcpatchTypes::tpcpatch(), Tpcpatch_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpatchseqarr_4params); auto tpcpatch_to_timespan_function = ScalarFunction( "timeSpan", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, SpanTypes::tstzspan(), Temporal_to_tstzspan); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_to_timespan_function); auto tpcpatch_to_tinstant_function = ScalarFunction( "tpcpatchInst", - {TPcpatchTypes::TPCPATCH()}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch()}, + TPcpatchTypes::tpcpatch(), Temporal_to_tinstant); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_to_tinstant_function); auto setInterp_function = ScalarFunction( "setInterp", - {TPcpatchTypes::TPCPATCH(), LogicalType::VARCHAR}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch(), LogicalType::VARCHAR}, + TPcpatchTypes::tpcpatch(), Temporal_set_interp ); duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); @@ -1233,15 +1196,15 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto merge_function = ScalarFunction( "merge", - {TPcpatchTypes::TPCPATCH(), TPcpatchTypes::TPCPATCH()}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch(), TPcpatchTypes::tpcpatch()}, + TPcpatchTypes::tpcpatch(), Temporal_merge ); duckdb::RegisterSerializedScalarFunction(loader, merge_function); auto tempSubtype_function = ScalarFunction( "tempSubtype", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Temporal_subtype ); @@ -1249,7 +1212,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto interp_function = ScalarFunction( "interp", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Temporal_interp ); @@ -1257,7 +1220,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto memSize_function = ScalarFunction( "memSize", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Temporal_mem_size ); @@ -1265,32 +1228,20 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto getValue_function = ScalarFunction( "getValue", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::VARCHAR, Tinstant_value ); duckdb::RegisterSerializedScalarFunction(loader, getValue_function); - auto tpcpatch_start_value_function = ScalarFunction( - "startValue", - {TPcpatchTypes::TPCPATCH()}, - LogicalType::VARCHAR, - Temporal_start_value - ); - duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_start_value_function); - - auto tpcpatch_end_value_function = ScalarFunction( - "endValue", - {TPcpatchTypes::TPCPATCH()}, - LogicalType::VARCHAR, - Temporal_end_value - ); - duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_end_value_function); + /* startValue/endValue are now GENERATED (they return the pcpatch base value, + * rendered as hex-WKB text via the pcpatch->VARCHAR cast), mirroring the cbuffer + * sibling; the hand VARCHAR registrations are retired to avoid an ambiguous overload. */ auto tpcpatch_pcid_function = ScalarFunction( "pcid", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Tpcpatch_pcid ); @@ -1298,7 +1249,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tpcpatch_numpoints_function = ScalarFunction( "numPoints", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::INTEGER, Tpcpatch_numpoints ); @@ -1306,24 +1257,24 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto startInstant_function = ScalarFunction( "startInstant", - {TPcpatchTypes::TPCPATCH()}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch()}, + TPcpatchTypes::tpcpatch(), Temporal_start_instant ); duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); auto endInstant_function = ScalarFunction( "endInstant", - {TPcpatchTypes::TPCPATCH()}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch()}, + TPcpatchTypes::tpcpatch(), Temporal_end_instant ); duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); auto instantN_function = ScalarFunction( "instantN", - {TPcpatchTypes::TPCPATCH(), LogicalType::INTEGER}, - TPcpatchTypes::TPCPATCH(), + {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER}, + TPcpatchTypes::tpcpatch(), Temporal_instant_n ); duckdb::RegisterSerializedScalarFunction(loader, instantN_function); @@ -1331,7 +1282,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tpcpatch_gettimestamptz_function = ScalarFunction( "getTimestamp", - {TPcpatchTypes::TPCPATCH()}, + {TPcpatchTypes::tpcpatch()}, LogicalType::TIMESTAMP_TZ, Tinstant_timestamptz); duckdb::RegisterSerializedScalarFunction(loader, tpcpatch_gettimestamptz_function); @@ -1344,7 +1295,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // generic handlers wired for tgeompoint in temporal_functions.cpp. // =================================================================== - const LogicalType TGEOM = TPcpatchTypes::TPCPATCH(); + const LogicalType TGEOM = TPcpatchTypes::tpcpatch(); const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; const LogicalType IVAL = LogicalType::INTERVAL; @@ -1521,7 +1472,8 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } void TPcpatchTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TPCPATCH", TPcpatchTypes::TPCPATCH()); + loader.RegisterType( "pcpatch", TPcpatchTypes::pcpatch()); + loader.RegisterType( "tpcpatch", TPcpatchTypes::tpcpatch()); } diff --git a/src/pointcloud/tpcpatch_in_out.cpp b/src/pointcloud/tpcpatch_in_out.cpp index fdef7326..904880d5 100644 --- a/src/pointcloud/tpcpatch_in_out.cpp +++ b/src/pointcloud/tpcpatch_in_out.cpp @@ -25,7 +25,7 @@ namespace duckdb { // schema-dependent EWKT path is not meaningful for a pgpointcloud value // without a registered PCSCHEMA — so this port does not register an // asText / asEWKT overload (no unverified-parity over-emission). Text -// I/O is provided by the VARCHAR <-> TPCPATCH cast below. +// I/O is provided by the VARCHAR <-> tpcpatch cast below. bool TpcpatchFunctions::StringToTpcpatch(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { UnaryExecutor::Execute( @@ -38,14 +38,14 @@ bool TpcpatchFunctions::StringToTpcpatch(Vector &source, Vector &result, idx_t c // MobilityDB SQL binds tpcpatch_in to. Temporal *temp = temporal_in(input_str.c_str(), T_TPCPATCH); if (!temp) { - throw InvalidInputException("Invalid TPCPATCH input: " + input_str); + throw InvalidInputException("Invalid tpcpatch 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 TPCPATCH data"); + throw InvalidInputException("Failed to allocate memory for tpcpatch data"); } memcpy(data_buffer, temp, data_size); @@ -73,25 +73,25 @@ bool TpcpatchFunctions::TpcpatchToString(Vector &source, Vector &result, idx_t c size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TPCPATCH data: insufficient size"); + throw InvalidInputException("Invalid tpcpatch data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TPCPATCH deserialization"); + throw InvalidInputException("Failed to allocate memory for tpcpatch deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TPCPATCH data: null pointer"); + throw InvalidInputException("Invalid tpcpatch data: null pointer"); } char *str = temporal_out(temp, 15); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TPCPATCH to string"); + throw InvalidInputException("Failed to convert tpcpatch to string"); } std::string output(str); @@ -216,7 +216,7 @@ void TPcpatchTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ // ---- tpcpatchFromBinary / FromHexWKB / FromMFJSON / FromText ---- const auto B = LogicalType::BLOB; const auto V = LogicalType::VARCHAR; - const auto T = TPcpatchTypes::TPCPATCH(); + const auto T = TPcpatchTypes::tpcpatch(); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tpcpatchFromBinary", {B}, T, TspatialFromWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, @@ -256,8 +256,11 @@ void TPcpatchTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TPcpatchTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpatchTypes::TPCPATCH(), TpcpatchFunctions::StringToTpcpatch); - loader.RegisterCastFunction( TPcpatchTypes::TPCPATCH(), LogicalType::VARCHAR, TpcpatchFunctions::TpcpatchToString); + loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpatchTypes::tpcpatch(), TpcpatchFunctions::StringToTpcpatch); + loader.RegisterCastFunction( TPcpatchTypes::tpcpatch(), LogicalType::VARCHAR, TpcpatchFunctions::TpcpatchToString); + // Base pcpatch value render cast: generated startValue/endValue return the pcpatch + // base value, rendered as hex-WKB text via pcpatch_hex_out (cbuffer sibling pattern). + loader.RegisterCastFunction( TPcpatchTypes::pcpatch(), LogicalType::VARCHAR, TpcpatchFunctions::Pcpatch_out_cast); } } diff --git a/src/pointcloud/tpcpoint.cpp b/src/pointcloud/tpcpoint.cpp index 3edaaa7a..8a2c1585 100644 --- a/src/pointcloud/tpcpoint.cpp +++ b/src/pointcloud/tpcpoint.cpp @@ -45,9 +45,15 @@ extern "C" { namespace duckdb { -LogicalType TPcpointTypes::TPCPOINT() { +LogicalType TPcpointTypes::pcpoint() { auto type = LogicalType(LogicalTypeId::BLOB); - type.SetAlias("TPCPOINT"); + type.SetAlias("pcpoint"); + return type; +} + +LogicalType TPcpointTypes::tpcpoint() { + auto type = LogicalType(LogicalTypeId::BLOB); + type.SetAlias("tpcpoint"); return type; } @@ -69,7 +75,7 @@ static void Tpcpoint_constructor(DataChunk &args, ExpressionState &state, Vector // T_TPCPOINT). Temporal *tinst = temporal_in(input.c_str(), T_TPCPOINT); if (!tinst) { - throw InvalidInputException("Invalid TPCPOINT input: " + input); + throw InvalidInputException("Invalid tpcpoint input: " + input); } size_t data_size = temporal_mem_size(tinst); @@ -77,7 +83,7 @@ static void Tpcpoint_constructor(DataChunk &args, ExpressionState &state, Vector uint8_t *data_buffer = (uint8_t*)malloc(data_size); if (!data_buffer) { free(tinst); - throw InvalidInputException("Failed to allocate memory for TPCPOINT data"); + throw InvalidInputException("Failed to allocate memory for tpcpoint data"); } memcpy(data_buffer, tinst, data_size); @@ -444,13 +450,13 @@ static void Temporal_to_tstzspan(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } Span *timespan = temporal_to_tstzspan(temp); if (!timespan) { - throw InvalidInputException("Failed to extract timespan from TPCPOINT"); + throw InvalidInputException("Failed to extract timespan from tpcpoint"); } size_t span_size = sizeof(Span); @@ -494,12 +500,12 @@ static void Temporal_to_tinstant(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } TInstant *inst = temporal_as_tinstant(temp); if (!inst) { - throw InvalidInputException("Failed to convert TPCPOINT to TInstant"); + throw InvalidInputException("Failed to convert tpcpoint to TInstant"); } size_t inst_size = temporal_mem_size((Temporal*)inst); @@ -544,7 +550,7 @@ static void Temporal_set_interp(DataChunk &args, ExpressionState &state, Vector Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } std::string interp_str = interp_str_t.GetString(); @@ -594,14 +600,14 @@ static void Temporal_merge(DataChunk &args, ExpressionState &state, Vector &resu Temporal *temp1 = reinterpret_cast(const_cast(tgeom1.c_str())); if (!temp1) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } std::string tgeom2 = tgeom2_str_t.GetString(); Temporal *temp2 = reinterpret_cast(const_cast(tgeom2.c_str())); if (!temp2) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } Temporal *result_temp = temporal_merge(temp1, temp2); @@ -650,7 +656,7 @@ static void Temporal_subtype(DataChunk &args, ExpressionState &state, Vector &re Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } const char *subtype_str = temporal_subtype(temp); @@ -686,7 +692,7 @@ static void Temporal_interp(DataChunk &args, ExpressionState &state, Vector &res Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } @@ -719,7 +725,7 @@ static void Temporal_mem_size(DataChunk &args, ExpressionState &state, Vector &r Temporal *temp = reinterpret_cast(const_cast(input.c_str())); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } size_t mem_size = temporal_mem_size(temp); @@ -784,75 +790,32 @@ static void Tinstant_value(DataChunk &args, ExpressionState &state, Vector &resu -static void Temporal_start_value(DataChunk &args, ExpressionState &state, Vector &result) { - auto count = args.size(); - auto &input_vec = args.data[0]; +/* Temporal_start_value/Temporal_end_value retired: startValue/endValue are now + * generated (return the pcpoint base value, rendered via the pcpoint->VARCHAR cast). */ +/* Base pcpoint value (BLOB-alias) -> VARCHAR render cast, mirroring the cbuffer + * sibling's Cbuffer_out_cast. The generated startValue/endValue return the pcpoint + * base value; DuckDB renders it through this cast via the schema-free pcpoint_hex_out + * (hex-WKB text), the same form the retired hand accessors produced. */ +bool TpcpointFunctions::Pcpoint_out_cast( + Vector &source, Vector &result, idx_t count, CastParameters ¶meters) +{ UnaryExecutor::Execute( - input_vec, result, count, - [&](string_t input_str) -> string_t { - std::string input = input_str.GetString(); - - Temporal *temp = reinterpret_cast(const_cast(input.c_str())); - - // temporal_start_value returns a freshly allocated copy of - // the pcpoint value (datum_copy), which the caller owns. - Datum start_datum = temporal_start_value(temp); - - Pcpoint *pt = reinterpret_cast(start_datum); + source, result, count, + [&](string_t blob) -> string_t { + size_t sz = blob.GetSize(); + uint8_t *copy = (uint8_t *)malloc(sz); + memcpy(copy, blob.GetData(), sz); + Pcpoint *pt = reinterpret_cast(copy); char *str = pcpoint_hex_out(pt, 15); - if (!str) { - free(pt); - throw InvalidInputException("Failed to convert pcpoint value to text"); - } - std::string output(str); - string_t stored_result = StringVector::AddString(result, output); - - free(str); free(pt); - - return stored_result; - }); - - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } -} - - -static void Temporal_end_value(DataChunk &args, ExpressionState &state, Vector &result) { - auto count = args.size(); - auto &input_vec = args.data[0]; - - UnaryExecutor::Execute( - input_vec, result, count, - [&](string_t input_str) -> string_t { - std::string input = input_str.GetString(); - - Temporal *temp = reinterpret_cast(const_cast(input.c_str())); - - // temporal_end_value returns a freshly allocated copy of - // the pcpoint value (datum_copy), which the caller owns. - Datum end_datum = temporal_end_value(temp); - - Pcpoint *pt = reinterpret_cast(end_datum); - char *str = pcpoint_hex_out(pt, 15); - if (!str) { - free(pt); + if (!str) throw InvalidInputException("Failed to convert pcpoint value to text"); - } - std::string output(str); - string_t stored_result = StringVector::AddString(result, output); - + std::string s(str); free(str); - free(pt); - - return stored_result; + return StringVector::AddString(result, s); }); - - if (count == 1) { - result.SetVectorType(VectorType::CONSTANT_VECTOR); - } + return true; } static void Tpcpoint_pcid(DataChunk &args, ExpressionState &state, Vector &result) { @@ -1071,12 +1034,12 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector size_t data_size = input_geom_str.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TPCPOINT data: insufficient size"); + throw InvalidInputException("Invalid tpcpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TPCPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tpcpoint deserialization"); } memcpy(data_copy, data, data_size); @@ -1084,7 +1047,7 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } TimestampTz meos_t = temp->t; @@ -1107,87 +1070,87 @@ static void Tinstant_timestamptz(DataChunk &args, ExpressionState &state, Vector void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tpcpoint_function = ScalarFunction( - "TPCPOINT", + "tpcpoint", {LogicalType::VARCHAR}, - TPcpointTypes::TPCPOINT(), + TPcpointTypes::tpcpoint(), Tpcpoint_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_function); auto tpcpoint_from_timestamp_function = ScalarFunction( - "TPCPOINT", + "tpcpoint", {LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, - TPcpointTypes::TPCPOINT(), + TPcpointTypes::tpcpoint(), Tpcpointinst_constructor); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_from_timestamp_function); auto tpcpoint_from_tstzspan_function = ScalarFunction( - "TPCPOINT", + "tpcpoint", {LogicalType::VARCHAR, SpanTypes::tstzspan(), LogicalType::VARCHAR}, - TPcpointTypes::TPCPOINT(), + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_from_tstzspan_function); auto tpcpoint_from_tstzspan_default = ScalarFunction( - "TPCPOINT", + "tpcpoint", {LogicalType::VARCHAR, SpanTypes::tstzspan()}, - TPcpointTypes::TPCPOINT(), + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_from_tstzspan ); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_from_tstzspan_default); auto tpcpointseqarr_1param= ScalarFunction( "tpcpointSeq", - {LogicalType::LIST(TPcpointTypes::TPCPOINT())}, - TPcpointTypes::TPCPOINT(), + {LogicalType::LIST(TPcpointTypes::tpcpoint())}, + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpointseqarr_1param); auto tpcpointseqarr_2params = ScalarFunction( "tpcpointSeq", - {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR}, - TPcpointTypes::TPCPOINT(), + {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR}, + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpointseqarr_2params); auto tpcpointseqarr_3params = ScalarFunction( "tpcpointSeq", - {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, - TPcpointTypes::TPCPOINT(), + {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN}, + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpointseqarr_3params); auto tpcpointseqarr_4params = ScalarFunction( "tpcpointSeq", - {LogicalType::LIST(TPcpointTypes::TPCPOINT()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, - TPcpointTypes::TPCPOINT(), + {LogicalType::LIST(TPcpointTypes::tpcpoint()), LogicalType::VARCHAR, LogicalType::BOOLEAN, LogicalType::BOOLEAN}, + TPcpointTypes::tpcpoint(), Tpcpoint_sequence_constructor ); duckdb::RegisterSerializedScalarFunction(loader, tpcpointseqarr_4params); auto tpcpoint_to_timespan_function = ScalarFunction( "timeSpan", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, SpanTypes::tstzspan(), Temporal_to_tstzspan); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_to_timespan_function); auto tpcpoint_to_tinstant_function = ScalarFunction( "tpcpointInst", - {TPcpointTypes::TPCPOINT()}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint()}, + TPcpointTypes::tpcpoint(), Temporal_to_tinstant); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_to_tinstant_function); auto setInterp_function = ScalarFunction( "setInterp", - {TPcpointTypes::TPCPOINT(), LogicalType::VARCHAR}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint(), LogicalType::VARCHAR}, + TPcpointTypes::tpcpoint(), Temporal_set_interp ); duckdb::RegisterSerializedScalarFunction(loader, setInterp_function); @@ -1195,15 +1158,15 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto merge_function = ScalarFunction( "merge", - {TPcpointTypes::TPCPOINT(), TPcpointTypes::TPCPOINT()}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint(), TPcpointTypes::tpcpoint()}, + TPcpointTypes::tpcpoint(), Temporal_merge ); duckdb::RegisterSerializedScalarFunction(loader, merge_function); auto tempSubtype_function = ScalarFunction( "tempSubtype", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Temporal_subtype ); @@ -1211,7 +1174,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto interp_function = ScalarFunction( "interp", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Temporal_interp ); @@ -1219,7 +1182,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto memSize_function = ScalarFunction( "memSize", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Temporal_mem_size ); @@ -1227,32 +1190,20 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto getValue_function = ScalarFunction( "getValue", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::VARCHAR, Tinstant_value ); duckdb::RegisterSerializedScalarFunction(loader, getValue_function); - auto tpcpoint_start_value_function = ScalarFunction( - "startValue", - {TPcpointTypes::TPCPOINT()}, - LogicalType::VARCHAR, - Temporal_start_value - ); - duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_start_value_function); - - auto tpcpoint_end_value_function = ScalarFunction( - "endValue", - {TPcpointTypes::TPCPOINT()}, - LogicalType::VARCHAR, - Temporal_end_value - ); - duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_end_value_function); + /* startValue/endValue are now GENERATED (they return the pcpoint base value, + * rendered as hex-WKB text via the pcpoint->VARCHAR cast), mirroring the cbuffer + * sibling; the hand VARCHAR registrations are retired to avoid an ambiguous overload. */ auto tpcpoint_pcid_function = ScalarFunction( "pcid", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::INTEGER, Tpcpoint_pcid ); @@ -1260,24 +1211,24 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto startInstant_function = ScalarFunction( "startInstant", - {TPcpointTypes::TPCPOINT()}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint()}, + TPcpointTypes::tpcpoint(), Temporal_start_instant ); duckdb::RegisterSerializedScalarFunction(loader, startInstant_function); auto endInstant_function = ScalarFunction( "endInstant", - {TPcpointTypes::TPCPOINT()}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint()}, + TPcpointTypes::tpcpoint(), Temporal_end_instant ); duckdb::RegisterSerializedScalarFunction(loader, endInstant_function); auto instantN_function = ScalarFunction( "instantN", - {TPcpointTypes::TPCPOINT(), LogicalType::INTEGER}, - TPcpointTypes::TPCPOINT(), + {TPcpointTypes::tpcpoint(), LogicalType::INTEGER}, + TPcpointTypes::tpcpoint(), Temporal_instant_n ); duckdb::RegisterSerializedScalarFunction(loader, instantN_function); @@ -1285,7 +1236,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { auto tpcpoint_gettimestamptz_function = ScalarFunction( "getTimestamp", - {TPcpointTypes::TPCPOINT()}, + {TPcpointTypes::tpcpoint()}, LogicalType::TIMESTAMP_TZ, Tinstant_timestamptz); duckdb::RegisterSerializedScalarFunction(loader, tpcpoint_gettimestamptz_function); @@ -1298,7 +1249,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { // generic handlers wired for tgeompoint in temporal_functions.cpp. // =================================================================== - const LogicalType TGEOM = TPcpointTypes::TPCPOINT(); + const LogicalType TGEOM = TPcpointTypes::tpcpoint(); const LogicalType TSTZ = LogicalType::TIMESTAMP_TZ; const LogicalType IVAL = LogicalType::INTERVAL; @@ -1475,7 +1426,8 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) { } void TPcpointTypes::RegisterTypes(ExtensionLoader &loader) { - loader.RegisterType( "TPCPOINT", TPcpointTypes::TPCPOINT()); + loader.RegisterType( "pcpoint", TPcpointTypes::pcpoint()); + loader.RegisterType( "tpcpoint", TPcpointTypes::tpcpoint()); } diff --git a/src/pointcloud/tpcpoint_in_out.cpp b/src/pointcloud/tpcpoint_in_out.cpp index 8c77c6bf..d726a6e6 100644 --- a/src/pointcloud/tpcpoint_in_out.cpp +++ b/src/pointcloud/tpcpoint_in_out.cpp @@ -25,7 +25,7 @@ namespace duckdb { // schema-dependent EWKT path is not meaningful for a pgpointcloud value // without a registered PCSCHEMA — so this port does not register an // asText / asEWKT overload (no unverified-parity over-emission). Text -// I/O is provided by the VARCHAR <-> TPCPOINT cast below. +// I/O is provided by the VARCHAR <-> tpcpoint cast below. bool TpcpointFunctions::StringToTpcpoint(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { UnaryExecutor::Execute( @@ -38,14 +38,14 @@ bool TpcpointFunctions::StringToTpcpoint(Vector &source, Vector &result, idx_t c // MobilityDB SQL binds tpcpoint_in to. Temporal *temp = temporal_in(input_str.c_str(), T_TPCPOINT); if (!temp) { - throw InvalidInputException("Invalid TPCPOINT input: " + input_str); + throw InvalidInputException("Invalid tpcpoint 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 TPCPOINT data"); + throw InvalidInputException("Failed to allocate memory for tpcpoint data"); } memcpy(data_buffer, temp, data_size); @@ -73,25 +73,25 @@ bool TpcpointFunctions::TpcpointToString(Vector &source, Vector &result, idx_t c size_t data_size = input_blob.GetSize(); if (data_size < sizeof(void*)) { - throw InvalidInputException("Invalid TPCPOINT data: insufficient size"); + throw InvalidInputException("Invalid tpcpoint data: insufficient size"); } uint8_t *data_copy = (uint8_t*)malloc(data_size); if (!data_copy) { - throw InvalidInputException("Failed to allocate memory for TPCPOINT deserialization"); + throw InvalidInputException("Failed to allocate memory for tpcpoint deserialization"); } memcpy(data_copy, data, data_size); Temporal *temp = reinterpret_cast(data_copy); if (!temp) { free(data_copy); - throw InvalidInputException("Invalid TPCPOINT data: null pointer"); + throw InvalidInputException("Invalid tpcpoint data: null pointer"); } char *str = temporal_out(temp, 15); if (!str) { free(data_copy); - throw InvalidInputException("Failed to convert TPCPOINT to string"); + throw InvalidInputException("Failed to convert tpcpoint to string"); } std::string output(str); @@ -218,7 +218,7 @@ void TPcpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ // ---- tpcpointFromBinary / FromHexWKB / FromMFJSON / FromText ---- const auto B = LogicalType::BLOB; const auto V = LogicalType::VARCHAR; - const auto T = TPcpointTypes::TPCPOINT(); + const auto T = TPcpointTypes::tpcpoint(); duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("tpcpointFromBinary", {B}, T, TspatialFromWkbExec)); duckdb::RegisterSerializedScalarFunction(loader, @@ -258,8 +258,11 @@ void TPcpointTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){ void TPcpointTypes::RegisterCastFunctions(ExtensionLoader &loader) { - loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpointTypes::TPCPOINT(), TpcpointFunctions::StringToTpcpoint); - loader.RegisterCastFunction( TPcpointTypes::TPCPOINT(), LogicalType::VARCHAR, TpcpointFunctions::TpcpointToString); + loader.RegisterCastFunction( LogicalType::VARCHAR, TPcpointTypes::tpcpoint(), TpcpointFunctions::StringToTpcpoint); + loader.RegisterCastFunction( TPcpointTypes::tpcpoint(), LogicalType::VARCHAR, TpcpointFunctions::TpcpointToString); + // Base pcpoint value render cast: generated startValue/endValue return the pcpoint + // base value, rendered as hex-WKB text via pcpoint_hex_out (cbuffer sibling pattern). + loader.RegisterCastFunction( TPcpointTypes::pcpoint(), LogicalType::VARCHAR, TpcpointFunctions::Pcpoint_out_cast); } } diff --git a/tools/codegen_duck_udfs.py b/tools/codegen_duck_udfs.py index 75957bf7..3f6469da 100644 --- a/tools/codegen_duck_udfs.py +++ b/tools/codegen_duck_udfs.py @@ -45,6 +45,8 @@ def base(canon): "TBox": ("LogicalType::BLOB", "BlobToTbox(%s)"), "Cbuffer": ("CbufferTypes::cbuffer()", "BlobToCbuffer(%s)"), "Jsonb": ("TJsonbTypes::jsonb()", "BlobToJsonb(%s)"), + "Pcpoint": ("TPcpointTypes::pcpoint()", "BlobToPcpoint(%s)"), + "Pcpatch": ("TPcpatchTypes::pcpatch()", "BlobToPcpatch(%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)"), @@ -58,6 +60,8 @@ def base(canon): "TBox": ("LogicalType::BLOB", "TboxToBlob(result, %s)"), "Cbuffer": ("CbufferTypes::cbuffer()", "CbufferToBlob(result, %s)"), "Jsonb": ("TJsonbTypes::jsonb()", "JsonbToBlob(result, %s)"), + "Pcpoint": ("TPcpointTypes::pcpoint()", "PcpointToBlob(result, %s)"), + "Pcpatch": ("TPcpatchTypes::pcpatch()", "PcpatchToBlob(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 * @@ -178,6 +182,7 @@ def ret_type(f, out_canon): "tgeompoint", "tgeogpoint", "tgeometry", "tgeography", "tgeo", "tspatial", "tquadbin", "tcbuffer", "cbuffer", "th3index", "h3index", "tjsonb", "jsonb", + "tpcpoint", "pcpoint", "tpcpatch", "pcpatch", } # 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. @@ -434,6 +439,14 @@ def reg_scope(name): # temporal, transforms) emits here. if name.startswith("tjsonb_") or re.search(r'_tjsonb(?=_|$)', name): return ("types", ["TJsonbTypes::tjsonb()"]) + # the temporal pointcloud families (their own gated types): a tpcpoint_*/tpcpatch_* + # prefix, or a _tpcpoint/_tpcpatch token anywhere. The base pcpoint/pcpatch-value-coupled + # accessors marshal via the Pcpoint/Pcpatch varlena marshaller; geometry-coupled variants + # auto-exclude on their unmarshallable arg/return. + if name.startswith("tpcpoint_") or re.search(r'_tpcpoint(?=_|$)', name): + return ("types", ["TPcpointTypes::tpcpoint()"]) + if name.startswith("tpcpatch_") or re.search(r'_tpcpatch(?=_|$)', name): + return ("types", ["TPcpatchTypes::tpcpatch()"]) # 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 @@ -457,7 +470,8 @@ def reg_scope(name): "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()", "tgeompoint": "TgeompointType::tgeompoint()", "tgeogpoint": "TgeogpointType::tgeogpoint()", "tcbuffer": "CbufferTypes::tcbuffer()", "th3index": "H3indexTypes::th3index()", - "tquadbin": "QuadbinTypes::tquadbin()", "tjsonb": "TJsonbTypes::tjsonb()"} + "tquadbin": "QuadbinTypes::tquadbin()", "tjsonb": "TJsonbTypes::tjsonb()", + "tpcpoint": "TPcpointTypes::tpcpoint()", "tpcpatch": "TPcpatchTypes::tpcpatch()"} 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 @@ -495,6 +509,7 @@ def ret_temporal_type(name, arg_acc, group="", sql_ret=None): "tgeometry": "TGeometryTypes::tgeometry()", "tgeography": "TGeographyTypes::tgeography()", "tcbuffer": "CbufferTypes::tcbuffer()", "th3index": "H3indexTypes::th3index()", "tquadbin": "QuadbinTypes::tquadbin()", "tjsonb": "TJsonbTypes::tjsonb()", + "tpcpoint": "TPcpointTypes::tpcpoint()", "tpcpatch": "TPcpatchTypes::tpcpatch()", } def sig_declared_accs(f): """The exact temporal-operand types this GENERIC (`Temporal *`) function is CREATE @@ -3045,12 +3060,15 @@ def gen_cpp(fns, out_path, declared=None, aliases=None): '#include "h3/th3index.hpp"\n' # H3indexTypes::h3index()/th3index() '#include "quadbin/tquadbin.hpp"\n' # QuadbinTypes::quadbin()/tquadbin() '#include "json/tjsonb.hpp"\n' # TJsonbTypes::jsonb()/tjsonb() + '#include "pointcloud/tpcpoint.hpp"\n' # TPcpointTypes::pcpoint()/tpcpoint() + '#include "pointcloud/tpcpatch.hpp"\n' # TPcpatchTypes::pcpatch()/tpcpatch() '#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 "meos_json.h"\n' # Jsonb type (via pgtypes.h) + tjsonb_*/jsonb_* fns + '#include "meos_pointcloud.h"\n' # Pcpoint/Pcpatch types + tpcpoint/tpcpatch fns '#include "time_util.hpp"\n' '#include "mobilityduck/meos_exec_serial.hpp"\n' '#include "duckdb/function/scalar_function.hpp"\n' @@ -3138,6 +3156,28 @@ def gen_cpp(fns, out_path, declared=None, aliases=None): " uint8_t *copy = (uint8_t *)malloc(sz);\n" " memcpy(copy, blob.GetData(), sz);\n" " return reinterpret_cast(copy);\n}\n" + "// Self-contained blob<->Pcpoint/Pcpatch marshalling. Both are varlena (vl_len_\n" + "// header) -> VARSIZE out; the stored BLOB is the raw bytes (mirror Cbuffer).\n" + "inline string_t PcpointToBlob(Vector &result, Pcpoint *pt) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)pt, VARSIZE(pt));\n" + " free(pt);\n return out;\n}\n" + "inline string_t PcpointToBlobN(Vector &result, Pcpoint *pt, ValidityMask &mask, idx_t idx) {\n" + " if (!pt) { mask.SetInvalid(idx); return string_t(); }\n return PcpointToBlob(result, pt);\n}\n" + "inline Pcpoint *BlobToPcpoint(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" + "inline string_t PcpatchToBlob(Vector &result, Pcpatch *pa) {\n" + " string_t out = StringVector::AddStringOrBlob(result, (const char *)pa, VARSIZE(pa));\n" + " free(pa);\n return out;\n}\n" + "inline string_t PcpatchToBlobN(Vector &result, Pcpatch *pa, ValidityMask &mask, idx_t idx) {\n" + " if (!pa) { mask.SetInvalid(idx); return string_t(); }\n return PcpatchToBlob(result, pa);\n}\n" + "inline Pcpatch *BlobToPcpatch(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" diff --git a/vcpkg_ports/meos/vcpkg.json b/vcpkg_ports/meos/vcpkg.json index 61bf49f2..d1cb5854 100644 --- a/vcpkg_ports/meos/vcpkg.json +++ b/vcpkg_ports/meos/vcpkg.json @@ -1,7 +1,7 @@ { "name": "meos", "version-string": "git", - "port-version": 11, + "port-version": 12, "description": "MEOS - Mobility Engine Open Source C library (built from MobilityDB with -DMEOS=ON)", "homepage": "https://libmeos.org/", "dependencies": [