From 45931723f724e6ad3da90f2867c7edebfdae8e9d Mon Sep 17 00:00:00 2001 From: Esteban Zimanyi Date: Thu, 3 Sep 2026 19:24:27 +0200 Subject: [PATCH] Derive the enum type mapping from the catalog TYPE_MAP hand-wrote a row per enum, and a hand list goes short and goes stale in both directions at once. It named 6 of the 14 enums the catalog declares, so a parameter of any other one had no mapping and the wrapper came out as a TODO stub reading `unsupported param`; and it carried 2 rows -- RTreeSearchOp and errorLevel -- for enums the catalog no longer declares and no function names. `configure(idl)` takes the SET from the catalog instead, the shape MEOS.NET's tools/codegen.py states at its own ENUM_TYPES, whose comment gives the reason in one line: taking the set from the catalog is what keeps a newly added enum from arriving unmapped the way a hand list leaves it. An enum MEOS adds is mapped the day it lands, and one it retires stops being mapped. ENUM_GO_NAME stays and is now stated for what it is: a SPELLING map, not an exclusion. It fixes only the names PascalCase would not produce -- `interpType` reaches Go as the published `Interpolation` -- and `emit_types` reads the same helper, so the two cannot disagree about a name. Its dead RTreeSearchOp row goes with the others. MEASURED: the flat surface goes 3563 -> 3580 wrappers and the TODO stubs 26 -> 9, closing exactly the enum class -- IndexSearchOp 9 and SPTreeKind 8, which is 17 of 17. MeosPixType's 4 stay out because they live in meos_raster.h, which is not in HEADER_FILES: the raster family is not generated at all, a scope decision this does not touch. The 9 stubs that remain are other shapes entirely (float8, float4, Oid, Numeric, SpaceSplit, SpaceTimeSplit, MvtGeom, meos_malloc_fn, a PoseChain out-parameter). The object layer follows to 1270 methods and 91 deferred. `go build ./...` over all 12 packages, `go vet ./types` and the parity gate exit 0; a second generator run reproduces the tree byte for byte. `gofmt -l` reads 14 files before and after -- the flat output has never been gofmt-clean and this does not move it. --- functions/meos_meos.go | 184 ++++++++++++++++++++++++++------ functions/meos_meos_internal.go | 11 +- tools/codegen.py | 52 ++++++--- types/rtree.go | 27 +++++ types/sptree.go | 99 +++++++++++++++++ 5 files changed, 325 insertions(+), 48 deletions(-) diff --git a/functions/meos_meos.go b/functions/meos_meos.go index 0ce5f79..0977084 100644 --- a/functions/meos_meos.go +++ b/functions/meos_meos.go @@ -649,20 +649,52 @@ func RtreeInsertTemporalSplit(rtree *RTree, temp *Temporal, id int64, maxboxes i } -// TODO rtree_search: unsupported param IndexSearchOp -// func RtreeSearch(...) { /* not yet handled by codegen */ } +// RtreeSearch wraps MEOS C function rtree_search. +func RtreeSearch(rtree *RTree, op IndexSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.rtree_search(rtree._inner, C.IndexSearchOp(op), unsafe.Pointer(query), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO rtree_join: unsupported param IndexSearchOp -// func RtreeJoin(...) { /* not yet handled by codegen */ } +// RtreeJoin wraps MEOS C function rtree_join. +func RtreeJoin(rtree1 *RTree, rtree2 *RTree, op IndexSearchOp) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.rtree_join(rtree1._inner, rtree2._inner, C.IndexSearchOp(op), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO rtree_search_temporal: unsupported param IndexSearchOp -// func RtreeSearchTemporal(...) { /* not yet handled by codegen */ } +// RtreeSearchTemporal wraps MEOS C function rtree_search_temporal. +func RtreeSearchTemporal(rtree *RTree, op IndexSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.rtree_search_temporal(rtree._inner, C.IndexSearchOp(op), temp._inner, &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO rtree_search_temporal_dedup: unsupported param IndexSearchOp -// func RtreeSearchTemporalDedup(...) { /* not yet handled by codegen */ } +// RtreeSearchTemporalDedup wraps MEOS C function rtree_search_temporal_dedup. +func RtreeSearchTemporalDedup(rtree *RTree, op IndexSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.rtree_search_temporal_dedup(rtree._inner, C.IndexSearchOp(op), temp._inner, C.int(maxboxes), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} // RtreeNnCursorOpen wraps MEOS C function rtree_nn_cursor_open. @@ -698,36 +730,92 @@ func RtreeNnCursorClose(cursor unsafe.Pointer) (_err error) { } -// TODO sptree_create_intspan: unsupported param SPTreeKind -// func SptreeCreateIntspan(...) { /* not yet handled by codegen */ } +// SptreeCreateIntspan wraps MEOS C function sptree_create_intspan. +func SptreeCreateIntspan(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_intspan(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_bigintspan: unsupported param SPTreeKind -// func SptreeCreateBigintspan(...) { /* not yet handled by codegen */ } +// SptreeCreateBigintspan wraps MEOS C function sptree_create_bigintspan. +func SptreeCreateBigintspan(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_bigintspan(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_floatspan: unsupported param SPTreeKind -// func SptreeCreateFloatspan(...) { /* not yet handled by codegen */ } +// SptreeCreateFloatspan wraps MEOS C function sptree_create_floatspan. +func SptreeCreateFloatspan(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_floatspan(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_datespan: unsupported param SPTreeKind -// func SptreeCreateDatespan(...) { /* not yet handled by codegen */ } +// SptreeCreateDatespan wraps MEOS C function sptree_create_datespan. +func SptreeCreateDatespan(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_datespan(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_tstzspan: unsupported param SPTreeKind -// func SptreeCreateTstzspan(...) { /* not yet handled by codegen */ } +// SptreeCreateTstzspan wraps MEOS C function sptree_create_tstzspan. +func SptreeCreateTstzspan(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_tstzspan(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_tbox: unsupported param SPTreeKind -// func SptreeCreateTBOX(...) { /* not yet handled by codegen */ } +// SptreeCreateTBOX wraps MEOS C function sptree_create_tbox. +func SptreeCreateTBOX(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_tbox(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_stbox: unsupported param SPTreeKind -// func SptreeCreateSTBOX(...) { /* not yet handled by codegen */ } +// SptreeCreateSTBOX wraps MEOS C function sptree_create_stbox. +func SptreeCreateSTBOX(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_stbox(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} -// TODO sptree_create_tpcbox: unsupported param SPTreeKind -// func SptreeCreateTpcbox(...) { /* not yet handled by codegen */ } +// SptreeCreateTpcbox wraps MEOS C function sptree_create_tpcbox. +func SptreeCreateTpcbox(kind SPTreeKind) (_r0 unsafe.Pointer, _err error) { + C.meos_errno_reset() + _cret := C.sptree_create_tpcbox(C.SPTreeKind(kind)) + if _err = meosError(); _err != nil { + return + } + return unsafe.Pointer(_cret), nil +} // SptreeFree wraps MEOS C function sptree_free. @@ -818,20 +906,52 @@ func SptreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int64, } -// TODO sptree_search: unsupported param IndexSearchOp -// func SptreeSearch(...) { /* not yet handled by codegen */ } +// SptreeSearch wraps MEOS C function sptree_search. +func SptreeSearch(sptree unsafe.Pointer, op IndexSearchOp, query unsafe.Pointer) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.sptree_search((*C.SPTree)(unsafe.Pointer(sptree)), C.IndexSearchOp(op), unsafe.Pointer(query), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO sptree_join: unsupported param IndexSearchOp -// func SptreeJoin(...) { /* not yet handled by codegen */ } +// SptreeJoin wraps MEOS C function sptree_join. +func SptreeJoin(sptree1 unsafe.Pointer, sptree2 unsafe.Pointer, op IndexSearchOp) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.sptree_join((*C.SPTree)(unsafe.Pointer(sptree1)), (*C.SPTree)(unsafe.Pointer(sptree2)), C.IndexSearchOp(op), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO sptree_search_temporal: unsupported param IndexSearchOp -// func SptreeSearchTemporal(...) { /* not yet handled by codegen */ } +// SptreeSearchTemporal wraps MEOS C function sptree_search_temporal. +func SptreeSearchTemporal(sptree unsafe.Pointer, op IndexSearchOp, temp *Temporal) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.sptree_search_temporal((*C.SPTree)(unsafe.Pointer(sptree)), C.IndexSearchOp(op), temp._inner, &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} -// TODO sptree_search_temporal_dedup: unsupported param IndexSearchOp -// func SptreeSearchTemporalDedup(...) { /* not yet handled by codegen */ } +// SptreeSearchTemporalDedup wraps MEOS C function sptree_search_temporal_dedup. +func SptreeSearchTemporalDedup(sptree unsafe.Pointer, op IndexSearchOp, temp *Temporal, maxboxes int) (_r0 int, _r1 *MeosArray, _err error) { + var _out_result C.MeosArray + C.meos_errno_reset() + _cret := C.sptree_search_temporal_dedup((*C.SPTree)(unsafe.Pointer(sptree)), C.IndexSearchOp(op), temp._inner, C.int(maxboxes), &_out_result) + if _err = meosError(); _err != nil { + return + } + return int(_cret), &MeosArray{_inner: &_out_result}, nil +} // SptreeNnCursorOpen wraps MEOS C function sptree_nn_cursor_open. diff --git a/functions/meos_meos_internal.go b/functions/meos_meos_internal.go index e53fea4..0bfd366 100644 --- a/functions/meos_meos_internal.go +++ b/functions/meos_meos_internal.go @@ -574,8 +574,15 @@ func EnsureSameIndexBboxtype(bboxtype1 MeosType, bboxtype2 MeosType) (_r0 bool, } -// TODO ensure_index_join_op: unsupported param IndexSearchOp -// func EnsureIndexJoinOp(...) { /* not yet handled by codegen */ } +// EnsureIndexJoinOp wraps MEOS C function ensure_index_join_op. +func EnsureIndexJoinOp(op IndexSearchOp) (_r0 bool, _err error) { + C.meos_errno_reset() + _cret := C.ensure_index_join_op(C.IndexSearchOp(op)) + if _err = meosError(); _err != nil { + return + } + return bool(_cret), nil +} // BboxTemporalSplitBoxes wraps MEOS C function bbox_temporal_split_boxes. diff --git a/tools/codegen.py b/tools/codegen.py index 9d4bf98..efab628 100644 --- a/tools/codegen.py +++ b/tools/codegen.py @@ -210,14 +210,8 @@ class TypeMapping: "error_handler_fn": TypeMapping("unsafe.Pointer", "(*[0]byte)({})", "{}"), "int (*)(void *, void *)": TypeMapping("unsafe.Pointer", "(*[0]byte)({})", "{}"), "void *(*)(void *, void *)": TypeMapping("unsafe.Pointer", "(*[0]byte)({})", "{}"), - "interpType": TypeMapping("Interpolation", "C.interpType({})", "Interpolation({})"), - "MeosType": TypeMapping("MeosType", "C.MeosType({})", "MeosType({})"), - "MeosOper": TypeMapping("MeosOper", "C.MeosOper({})", "MeosOper({})"), - "RTreeSearchOp": TypeMapping("RTreeSearchOp", "C.RTreeSearchOp({})", "RTreeSearchOp({})"), - "nullHandleType": TypeMapping("NullHandleType", "C.nullHandleType({})", "NullHandleType({})"), - "tempSubtype": TypeMapping("TempSubtype", "C.tempSubtype({})", "TempSubtype({})"), - "errorLevel": TypeMapping("ErrorLevel", "C.errorLevel({})", "ErrorLevel({})"), - "SkipListType": TypeMapping("SkipListType", "C.SkipListType({})", "SkipListType({})"), + # NO ENUM ROW IS WRITTEN HERE: ``configure()`` derives one per catalog enum, so an + # enum MEOS adds is mapped the day it lands and one it retires stops being mapped. "char *": TypeMapping("string", "C.CString({})", "C.GoString({})"), "const char *": TypeMapping("string", "C.CString({})", "C.GoString({})"), # PostgreSQL ``text`` is a varlena envelope around a Go string. The @@ -283,21 +277,50 @@ class TypeMapping: # CODEGEN-REGULAR-EXCEPTION: ENUM_GO_NAME is a NAME MAP, not an exclusion. -# emit_types() below iterates EVERY catalog enum and emits a Go type for each; -# this dict only overrides the Go spelling for the seven enums the wrapper -# TYPE_MAP already references (so the names line up), and every other enum -# falls back to PascalCase via `.get(c_name, _go_name(c_name))`. Zero enums are -# dropped or left unclassified. +# emit_types() iterates EVERY catalog enum and emits a Go type for each, and +# configure() maps every one of them for parameters and results; this dict only +# fixes the Go SPELLING where PascalCase would not produce the name the package +# already publishes -- `interpType` reaches Go as `Interpolation`, which no +# mechanical rule yields and which is a published name +# ([[never-change-api-surface-autonomously]]). Every other enum falls back to +# `_go_name(c_name)`. Zero enums are dropped or left unclassified. ENUM_GO_NAME: dict[str, str] = { "interpType": "Interpolation", "MeosType": "MeosType", "MeosOper": "MeosOper", - "RTreeSearchOp": "RTreeSearchOp", "nullHandleType": "NullHandleType", "tempSubtype": "TempSubtype", "SkipListType": "SkipListType", } +# The catalog's enums, filled in by ``configure``. An enum crosses cgo as its own +# Go type, and taking the SET from the catalog is what keeps an enum MEOS adds +# from arriving unmapped the way a hand list leaves it -- the shape MEOS.NET's +# tools/codegen.py states at its own ENUM_TYPES. +ENUM_TYPES: set[str] = set() + + +def configure(idl: dict) -> None: + """Take from the catalog the type facts the mapping above reads. + + A HAND LIST GOES SHORT AND ALSO GOES STALE, in both directions at once: the + rows this replaces named 6 of the 14 enums the catalog declares -- leaving + `IndexSearchOp` (9 functions), `SPTreeKind` (8) and `MeosPixType` (4) + unmapped, so 21 wrappers emitted a TODO stub reading `unsupported param` -- + and carried 2 more, `RTreeSearchOp` and `errorLevel`, for enums the catalog + no longer declares at all and no function names. + + The Go spelling comes from ENUM_GO_NAME where the published name is not what + PascalCase yields, so this and ``emit_types`` cannot disagree about a name: + both read the same helper. + """ + ENUM_TYPES.clear() + ENUM_TYPES.update(e["name"] for e in idl.get("enums", []) if e.get("name")) + for c_name in ENUM_TYPES: + go_name = ENUM_GO_NAME.get(c_name, _go_name(c_name)) + TYPE_MAP[c_name] = TypeMapping( + go_name, f"C.{c_name}({{}})", f"{go_name}({{}})") + def emit_types(idl: dict, corpus: str) -> str: """Emit the type layer the flat wrappers depend on: one opaque handle @@ -1171,6 +1194,7 @@ def _todo_stub(c_name: str, reason: str) -> str: def generate(idl_path: Path, out_dir: Path) -> dict: idl = json.loads(idl_path.read_text()) + configure(idl) out_dir.mkdir(parents=True, exist_ok=True) entries_by_file: dict[str, list[dict]] = {h: [] for h in HEADER_FILES} diff --git a/types/rtree.go b/types/rtree.go index 6ccf015..f61cb38 100644 --- a/types/rtree.go +++ b/types/rtree.go @@ -162,3 +162,30 @@ func (x *RTree) InsertTemporalSplit(temp *Temporal, id int64, maxboxes int) (boo } return _r0, nil } + +// Search is MEOS rtree_search. +func (x *RTree) Search(op functions.IndexSearchOp, query unsafe.Pointer) (int, *MeosArray, error) { + _r0, _r1, _err := functions.RtreeSearch(functions.RTreeFromPointer(x.Pointer()), op, query) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +} + +// Join is MEOS rtree_join. +func (x *RTree) Join(rtree2 *RTree, op functions.IndexSearchOp) (int, *MeosArray, error) { + _r0, _r1, _err := functions.RtreeJoin(functions.RTreeFromPointer(x.Pointer()), functions.RTreeFromPointer(rtree2.Pointer()), op) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +} + +// SearchTemporal is MEOS rtree_search_temporal. +func (x *RTree) SearchTemporal(op functions.IndexSearchOp, temp *Temporal) (int, *MeosArray, error) { + _r0, _r1, _err := functions.RtreeSearchTemporal(functions.RTreeFromPointer(x.Pointer()), op, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +} diff --git a/types/sptree.go b/types/sptree.go index a31e45a..e2c209a 100644 --- a/types/sptree.go +++ b/types/sptree.go @@ -23,6 +23,78 @@ func SPTreeFromPointer(p unsafe.Pointer) *SPTree { return v } +// SPTreeCreateIntspan is MEOS sptree_create_intspan. +func SPTreeCreateIntspan(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateIntspan(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateBigintspan is MEOS sptree_create_bigintspan. +func SPTreeCreateBigintspan(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateBigintspan(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateFloatspan is MEOS sptree_create_floatspan. +func SPTreeCreateFloatspan(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateFloatspan(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateDatespan is MEOS sptree_create_datespan. +func SPTreeCreateDatespan(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateDatespan(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateTstzspan is MEOS sptree_create_tstzspan. +func SPTreeCreateTstzspan(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateTstzspan(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateTbox is MEOS sptree_create_tbox. +func SPTreeCreateTbox(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateTBOX(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateStbox is MEOS sptree_create_stbox. +func SPTreeCreateStbox(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateSTBOX(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + +// SPTreeCreateTpcbox is MEOS sptree_create_tpcbox. +func SPTreeCreateTpcbox(kind functions.SPTreeKind) (unsafe.Pointer, error) { + _r0, _err := functions.SptreeCreateTpcbox(kind) + if _err != nil { + return nil, _err + } + return _r0, nil +} + // SPTreeFree is MEOS sptree_free. func SPTreeFree(sptree unsafe.Pointer) error { return functions.SptreeFree(sptree) @@ -90,3 +162,30 @@ func SPTreeInsertTemporalSplit(sptree unsafe.Pointer, temp *Temporal, id int64, } return _r0, nil } + +// SPTreeSearch is MEOS sptree_search. +func SPTreeSearch(sptree unsafe.Pointer, op functions.IndexSearchOp, query unsafe.Pointer) (int, *MeosArray, error) { + _r0, _r1, _err := functions.SptreeSearch(sptree, op, query) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +} + +// SPTreeJoin is MEOS sptree_join. +func SPTreeJoin(sptree1 unsafe.Pointer, sptree2 unsafe.Pointer, op functions.IndexSearchOp) (int, *MeosArray, error) { + _r0, _r1, _err := functions.SptreeJoin(sptree1, sptree2, op) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +} + +// SPTreeSearchTemporal is MEOS sptree_search_temporal. +func SPTreeSearchTemporal(sptree unsafe.Pointer, op functions.IndexSearchOp, temp *Temporal) (int, *MeosArray, error) { + _r0, _r1, _err := functions.SptreeSearchTemporal(sptree, op, functions.TemporalFromPointer(temp.Pointer())) + if _err != nil { + return 0, nil, _err + } + return _r0, MeosArrayFromPointer(_r1.Pointer()), nil +}