Map a parameter type by its canonical spelling and stop on an unknown one

tools/codegen reads each parameter's canonical spelling from the MEOS-API catalog, the C spelling with every typedef the catalog states resolved, and fills the one further parameter of a math operation by that spelling: argConversions fills a double, an int and a bool, so a typedef the catalog resolves to one of them is filled as that type. argUnfillable states the two types the one value of a query cannot fill, const Interval * and interpType, each with its reason, and an operation taking one keeps its row in mathOps and gets no case in the cgo dispatch. A parameter whose canonical spelling is absent, or names a type in neither map, stops the generator with an error naming the function and the type, so a type the catalog gives a parameter reaches the tier as a failing check rather than as an operation missing from the dispatch.

Measured. Over the catalog of MobilityDB master the generator selects 21 math operations and serves 18, the operations and cases of master's tables, whose generated dispatch differs only in the header comment naming the two unfillable types; the three without a case are the two taking an interval and the one taking an interpolation.

Witness. tools/codegen/main_test.go builds catalog entries and asserts that an int32 parameter whose canonical spelling is int is filled as an int, that an interval parameter keeps its operation out of the dispatch, and that a parameter of an unknown type, or one without a canonical spelling, stops the generator naming the function. GENERATION.md states the rule.

Author: estebanzimanyi

GENERATION.md

@@ -16,7 +16,13 @@ MEOS C symbol behind it, and the C type of its one further parameter.
 
 `mathops_meos_gen.go` is the cgo call for each of those operations, behind the
 `meos` build tag. It is what keeps a C symbol out of hand-written code: a MEOS
-rename becomes a compile error rather than a wrong call.
+rename becomes a compile error rather than a wrong call. The further parameter
+is filled from the one value a query carries according to the canonical
+spelling of its type, the C spelling with every typedef the catalog states
+resolved: `argConversions` in `tools/codegen` fills a `double`, an `int` and a
+`bool`, and `argUnfillable` states the types one value cannot fill, an interval
+and an interpolation, whose operations get no call. A type in neither stops the
+generator, naming the function that takes it.
 
 Run it against a catalog:
 

mathops_meos_gen.go

@@ -49,9 +49,13 @@ type function struct {
 	Returns  ctype   `json:"returnType"`
 }
 
+// param is one parameter of a catalog function: its C spelling as the header
+// writes it, and its canonical spelling, which is the C spelling with every
+// typedef the catalog states resolved.
 type param struct {
-	Name  string `json:"name"`
-	CType string `json:"cType"`
+	Name      string `json:"name"`
+	CType     string `json:"cType"`
+	Canonical string `json:"canonical"`
 }
 
 type ctype struct {
@@ -89,7 +93,10 @@ func main() {
 			"MEOS-API that states one, or it is not a MEOS-API catalog", *path))
 	}
 
-	ops := mathOperations(c.Functions)
+	ops, err := mathOperations(c.Functions)
+	if err != nil {
+		fail(fmt.Errorf("%s: %w", *path, err))
+	}
 	if len(ops) == 0 {
 		fail(fmt.Errorf("%s names no temporal math operation: the groups this reads, "+
 			"meos_temporal_math and meos_temporal_transf, are not where they were", *path))
@@ -139,9 +146,10 @@ var mathPrefixes = map[string]bool{
 // mathOperation is one MEOS function over a temporal number that the tier can
 // apply to a stream record.
 type mathOperation struct {
-	SQLName string // the SQL name, which is the same on every engine
-	Symbol  string // the MEOS C symbol
-	Arg     string // the C type of its one further parameter, empty when it takes none
+	SQLName      string // the SQL name, which is the same on every engine
+	Symbol       string // the MEOS C symbol
+	Arg          string // the C type of its one further parameter, empty when it takes none
+	ArgCanonical string // the canonical spelling of that type, empty when it takes none
 }
 
 // mathOperations selects, from the catalog, the functions that take a temporal
@@ -157,7 +165,13 @@ type mathOperation struct {
 //     arithmetic form <op>_tfloat_float;
 //   - it takes at most one further parameter, and that parameter is not itself
 //     a Temporal, since a stream record carries one value and not two.
-func mathOperations(fns []function) []mathOperation {
+//
+// The type of that further parameter is read by its canonical spelling, and it
+// must be one argConversions fills or one argUnfillable states a query value
+// cannot fill: any other type is an error, so a type the catalog gives a
+// parameter reaches this tier as a failing generator rather than as a missing
+// operation.
+func mathOperations(fns []function) ([]mathOperation, error) {
 	var out []mathOperation
 	for _, f := range fns {
 		if !mathGroups[f.Group] || f.Category != "transformation" || f.SQLName == "" {
@@ -176,32 +190,53 @@ func mathOperations(fns []function) []mathOperation {
 		if !mathPrefixes[strings.SplitN(f.Name, "_", 2)[0]] && !strings.HasSuffix(f.Name, "_tfloat_float") {
 			continue
 		}
-		arg := ""
+		op := mathOperation{SQLName: f.SQLName, Symbol: f.Name}
 		if len(rest) == 1 {
-			arg = rest[0].CType
+			op.Arg = rest[0].CType
+			op.ArgCanonical = rest[0].Canonical
+			if op.ArgCanonical == "" {
+				return nil, fmt.Errorf("%s: the parameter %s carries no canonical spelling, "+
+					"so its type cannot be read from the catalog", f.Name, rest[0].Name)
+			}
+			if _, ok := argConversions[op.ArgCanonical]; !ok {
+				if _, ok := argUnfillable[op.ArgCanonical]; !ok {
+					return nil, fmt.Errorf("%s: the parameter %s has the type %q, which is "+
+						"neither filled from a query value (argConversions) nor stated as one "+
+						"a query value cannot fill (argUnfillable)", f.Name, rest[0].Name, op.ArgCanonical)
+				}
+			}
 		}
-		out = append(out, mathOperation{SQLName: f.SQLName, Symbol: f.Name, Arg: arg})
+		out = append(out, op)
 	}
 	sort.Slice(out, func(i, j int) bool {
 		if out[i].SQLName != out[j].SQLName {
 			return out[i].SQLName < out[j].SQLName
 		}
 		return out[i].Symbol < out[j].Symbol
 	})
-	return out
+	return out, nil
 }
 
 // argConversions turn the one float64 a continuous query carries into the C
-// value a MEOS function's further parameter takes. A parameter type absent from
-// this map cannot be filled from a query, so the operation carrying it gets no
-// case and reaches the caller as one the dispatch does not serve.
+// value a MEOS function's further parameter takes, keyed by the canonical
+// spelling of the parameter's type, so a typedef the catalog resolves to one of
+// these types is filled as that type.
 var argConversions = map[string]string{
 	"":       "",
 	"double": "C.double(arg)",
 	"int":    "C.int(arg)",
 	"bool":   "arg != 0",
 }
 
+// argUnfillable are the canonical parameter types the one float64 of a query
+// cannot fill, each with the reason. An operation taking one of them gets no
+// case and reaches the caller as one the dispatch does not serve. A type in
+// neither this map nor argConversions stops the generator.
+var argUnfillable = map[string]string{
+	"const Interval *": "an interval is a duration, not a single number",
+	"interpType":       "an interpolation is an enumeration, not a number",
+}
+
 // renderDispatch writes the cgo call for each operation, which is what keeps
 // the C symbol behind an operation out of hand-written code: the symbol comes
 // from the catalog, and a MEOS rename becomes a compile error here rather than
@@ -217,8 +252,9 @@ func renderDispatch(ops []mathOperation) ([]byte, int, error) {
 //	go run ./tools/codegen -catalog <meos-idl.json> -o-meos mathops_meos_gen.go
 //
 // One case per operation the catalog states over a temporal number, calling the
-// MEOS symbol the catalog names. An operation whose further parameter cannot be
-// filled from the single value a query carries gets no case.
+// MEOS symbol the catalog names. An operation whose further parameter has a type
+// the single value a query carries cannot fill, an interval or an
+// interpolation, gets no case.
 
 package main
 
@@ -237,7 +273,7 @@ func callMathOp(sqlName string, temp *C.Temporal, arg float64) (*C.Temporal, boo
 `)
 	called := 0
 	for _, op := range ops {
-		conv, ok := argConversions[op.Arg]
+		conv, ok := argConversions[op.ArgCanonical]
 		if !ok {
 			continue
 		}

tools/codegen/main.go

@@ -0,0 +1,81 @@
+package main
+
+// These test the generator's reading of parameter types by calling
+// #mathOperations and #renderDispatch directly, beside the checks of the
+// generated table in the tier's own catalog_test.go
+// (#TestTheCatalogStatesMoreThanTheTierLifts), which read its output.
+
+import (
+	"strings"
+	"testing"
+)
+
+// mathFunction is a catalog entry that passes every selection rule of
+// #mathOperations, with one further parameter of the given C and canonical
+// spellings.
+func mathFunction(name, cType, canonical string) function {
+	return function{
+		Name:     name,
+		Group:    "meos_temporal_math",
+		Category: "transformation",
+		SQLName:  name,
+		Params: []param{
+			{Name: "temp", CType: "const Temporal *", Canonical: "const Temporal *"},
+			{Name: "arg", CType: cType, Canonical: canonical},
+		},
+		Returns: ctype{C: "Temporal *"},
+	}
+}
+
+// A parameter whose C spelling is a typedef is filled by the type the catalog
+// resolves it to, so #renderDispatch serves it.
+func TestAParameterIsFilledByItsCanonicalType(t *testing.T) {
+	ops, err := mathOperations([]function{mathFunction("tfloat_scale", "int32", "int")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ops) != 1 || ops[0].Arg != "int32" || ops[0].ArgCanonical != "int" {
+		t.Fatalf("got %+v, want one operation with Arg int32 and ArgCanonical int", ops)
+	}
+	src, called, err := renderDispatch(ops)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if called != 1 || !strings.Contains(string(src), "C.tfloat_scale(temp, C.int(arg))") {
+		t.Fatalf("the dispatch serves %d operations, want the int32 parameter filled as an int:\n%s", called, src)
+	}
+}
+
+// A parameter of a type a query value cannot fill keeps its operation in the
+// table and out of the dispatch #renderDispatch writes.
+func TestAnUnfillableParameterGetsNoCase(t *testing.T) {
+	ops, err := mathOperations([]function{mathFunction("tfloat_shift", "const Interval *", "const Interval *")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ops) != 1 {
+		t.Fatalf("got %d operations, want 1", len(ops))
+	}
+	src, called, err := renderDispatch(ops)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if called != 0 || strings.Contains(string(src), "tfloat_shift") {
+		t.Fatalf("the dispatch serves %d operations, want none:\n%s", called, src)
+	}
+}
+
+// A parameter type #mathOperations does not know, or one the catalog gives no
+// canonical spelling, stops the generator and names the function.
+func TestAnUnknownParameterTypeStopsTheGenerator(t *testing.T) {
+	for _, tc := range []struct{ cType, canonical, want string }{
+		{"const Span *", "const Span *", `"const Span *"`},
+		{"int32", "", "no canonical spelling"},
+	} {
+		_, err := mathOperations([]function{mathFunction("tfloat_odd", tc.cType, tc.canonical)})
+		if err == nil || !strings.Contains(err.Error(), "tfloat_odd") || !strings.Contains(err.Error(), tc.want) {
+			t.Errorf("parameter %q canonical %q: got error %v, want one naming tfloat_odd and %s",
+				tc.cType, tc.canonical, err, tc.want)
+		}
+	}
+}