Add WithoutNormalize Compiler Option

compiler.go

@@ -20,13 +20,15 @@ type compiler struct {
 	builtinScope  *scopeinfo
 	scopes        []*scopeinfo
 	scopecnt      int
+	skipNormalize bool
 }
 
 // Code is a compiled jq query.
 type Code struct {
-	variables []string
-	codes     []*code
-	codeinfos []codeinfo
+	variables     []string
+	codes         []*code
+	codeinfos     []codeinfo
+	skipNormalize bool
 }
 
 // Run runs the code with the variable values (which should be in the
@@ -47,9 +49,16 @@ func (c *Code) RunWithContext(ctx context.Context, v any, values ...any) Iter {
 		return NewIter(&expectedVariableError{c.variables[len(values)]})
 	}
 	for i, v := range values {
-		values[i] = normalizeNumbers(v)
+		values[i] = c.normalize(v)
+	}
+	return newEnv(ctx).execute(c, c.normalize(v), values...)
+}
+
+func (c *Code) normalize(v any) any {
+	if c.skipNormalize {
+		return v
 	}
-	return newEnv(ctx).execute(c, normalizeNumbers(v), values...)
+	return Normalize(v)
 }
 
 type scopeinfo struct {
@@ -113,9 +122,10 @@ func Compile(q *Query, options ...CompilerOption) (*Code, error) {
 	c.optimizeTailRec()
 	c.optimizeCodeOps()
 	return &Code{
-		variables: c.variables,
-		codes:     c.codes,
-		codeinfos: c.codeinfos,
+		variables:     c.variables,
+		codes:         c.codes,
+		codeinfos:     c.codeinfos,
+		skipNormalize: c.skipNormalize,
 	}, nil
 }
 
@@ -132,6 +142,14 @@ func (c *compiler) compile(q *Query) error {
 	return nil
 }
 
+func (c *compiler) normalize(v any) any {
+	if c.skipNormalize {
+		return v
+	}
+
+	return Normalize(v)
+}
+
 func (c *compiler) compileImport(i *Import) error {
 	var path, alias string
 	var err error
@@ -160,7 +178,7 @@ func (c *compiler) compileImport(i *Import) error {
 		} else {
 			return fmt.Errorf("module not found: %q", path)
 		}
-		vals = normalizeNumbers(vals)
+		vals = c.normalize(vals)
 		c.append(&code{op: oppush, v: vals})
 		c.append(&code{op: opstore, v: c.pushVariable(alias)})
 		c.append(&code{op: oppush, v: vals})
@@ -1218,7 +1236,7 @@ func (c *compiler) funcInput(any, []any) any {
 	if !ok {
 		return errors.New("break")
 	}
-	return normalizeNumbers(v)
+	return c.normalize(v)
 }
 
 func (c *compiler) funcModulemeta(v any, _ []any) any {

compiler_test.go

@@ -340,6 +340,36 @@ func TestCodeRun_Race(t *testing.T) {
 	wg.Wait()
 }
 
+func TestCode_RunWithoutNormalize(t *testing.T) {
+	query, err := gojq.Parse(".foo")
+	if err != nil {
+		log.Fatalln(err)
+	}
+	code, err := gojq.Compile(query)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	input := map[string]any{"foo": int32(1)}
+	_ = code.RunWithContext(context.Background(), input)
+	switch v := input["foo"].(type) {
+	case int: // ok
+	default:
+		t.Fatalf("expected int, got %T", v)
+	}
+
+	code, err = gojq.Compile(query, gojq.WithoutNormalize())
+	if err != nil {
+		log.Fatalln(err)
+	}
+	input = map[string]any{"foo": int32(1)} //need to recreate it as it was modified
+	_ = code.RunWithContext(context.Background(), input)
+	switch v := input["foo"].(type) {
+	case int32: // ok
+	default:
+		t.Fatalf("expected int32, got %T", v)
+	}
+}
+
 func BenchmarkCompile(b *testing.B) {
 	cnt, err := os.ReadFile("builtin.jq")
 	if err != nil {

func.go

@@ -848,7 +848,7 @@ func funcFromJSON(v any) any {
 	if _, err := dec.Token(); err != io.EOF {
 		return &func0TypeError{"fromjson", v}
 	}
-	return normalizeNumbers(w)
+	return Normalize(w)
 }
 
 func funcFormat(v, x any) any {

normalize.go

@@ -25,7 +25,16 @@ func normalizeNumber(v json.Number) any {
 	return math.Inf(1)
 }
 
-func normalizeNumbers(v any) any {
+// Normalize any given data.
+//
+// This function will in particular change any given map[any]any
+// so that all the integer values will be of type int and all the
+// floating point values will be of type float64. This method will
+// modify the given data in place.
+//
+// Typically running a gojq query will normalize the data automatically
+// unless the [WithoutNormalize] option has been specified.
+func Normalize(v any) any {
 	switch v := v.(type) {
 	case json.Number:
 		return normalizeNumber(v)
@@ -70,12 +79,12 @@ func normalizeNumbers(v any) any {
 		return float64(v)
 	case []any:
 		for i, x := range v {
-			v[i] = normalizeNumbers(x)
+			v[i] = Normalize(x)
 		}
 		return v
 	case map[string]any:
 		for k, x := range v {
-			v[k] = normalizeNumbers(x)
+			v[k] = Normalize(x)
 		}
 		return v
 	default:

option.go

@@ -94,3 +94,11 @@ func WithInputIter(inputIter Iter) CompilerOption {
 		c.inputIter = inputIter
 	}
 }
+
+// WithoutNormalize ensures any given data won't be modified when executing code.
+// Note that the input data is expected to be normalized using the [Normalize] function.
+func WithoutNormalize() CompilerOption {
+	return func(c *compiler) {
+		c.skipNormalize = true
+	}
+}