Derive the enum type mapping from the catalog

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.

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.

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}