add support to return hash in integer format

Author: kaisecheng

.chloggen/ottl_murmurhash3_func.yaml

@@ -7,7 +7,7 @@ change_type: enhancement
 component: pkg/ottl
 
 # A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
-note: "Add `MurmurHash3` function to convert the `target` to a hexadecimal string of the murmurHash3 hash/digest"
+note: Add `MurmurHash3` function to convert the `target` to murmurHash3 hash
 
 # Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
 issues: [34077]

pkg/ottl/ottlfuncs/README.md

@@ -952,18 +952,21 @@ Examples:
 
 `MurmurHash3(target, Optional[version])`
 
-The `MurmurHash3` Converter converts the `target` to a hexadecimal string of murmurHash3 hash/digest
+The `MurmurHash3` Converter converts the `target` to murmurHash3 hash/digest.
 
-`target` is a Getter that returns a string.
+`target` is a Getter that returns a string. The default `version` is `v128_hash`.
 
-`version` is an optional string. MurmurHash3 has 32-bit and 128-bit versions. The default value is `128`. Valid values are `32` and `128`.
+If `version` is
 
-The returned type is `string`.
+- `v32_hash`: Uses 32-bit version and returns a signed integer hash.
+- `v128_hash`: Use 128-bit version and returns an array of two signed integer hash.
+- `v32_hex`: Uses 32-bit version and returns a hash in hexadecimal string format.
+- `v128_hex`: Uses 128-bit version and returns a hash in hexadecimal string format.
 
 Examples:
 
-- `MurmurHash3(attributes["device.name"])`
-- `MurmurHash3("sometext", version="32")`
+- `MurmurHash3(attributes["order.productId"])`
+- `MurmurHash3("sometext", version="v32_hex")`
 
 ### Nanoseconds
 

pkg/ottl/ottlfuncs/func_murmurhash3.go

@@ -15,13 +15,15 @@ import (
 )
 
 const (
-	v32  = "32"
-	v128 = "128" // default
+	v32Hash  = "v32_hash"
+	v32Hex   = "v32_hex"
+	v128Hash = "v128_hash" // default
+	v128Hex  = "v128_hex"
 )
 
 type MurmurHash3Arguments[K any] struct {
 	Target  ottl.StringGetter[K]
-	Version ottl.Optional[string] // 32-bit or 128-bit
+	Version ottl.Optional[string]
 }
 
 func NewMurmurHash3Factory[K any]() ottl.Factory[K] {
@@ -35,45 +37,60 @@ func createMurmurHash3Function[K any](_ ottl.FunctionContext, oArgs ottl.Argumen
 		return nil, fmt.Errorf("MurmurHash3Factory args must be of type *MurmurHash3Arguments[K]")
 	}
 
-	version := v128
+	version := v128Hash
 	if !args.Version.IsEmpty() {
 		v := args.Version.Get()
 
 		switch v {
-		case v32, v128:
+		case v32Hash, v32Hex, v128Hash, v128Hex:
 			version = v
 		default:
-			return nil, fmt.Errorf("invalid arguments: %s. Version should be either \"32\" or \"128\"", v)
+			return nil, fmt.Errorf("invalid arguments: %s", v)
 		}
 	}
 
-	return HexStringLittleEndianVariant(args.Target, version)
+	return murmurHash3(args.Target, version)
 }
 
-// HexStringLittleEndianVariant returns the hexadecimal representation of the hash in little-endian format.
-// MurmurHash3, developed by Austin Appleby, is sensitive to endianness. Other languages like Python, Ruby,
-// and Java (using Guava) return a hexadecimal string in the little-endian variant. This function does the same.
-func HexStringLittleEndianVariant[K any](target ottl.StringGetter[K], version string) (ottl.ExprFunc[K], error) {
+func murmurHash3[K any](target ottl.StringGetter[K], version string) (ottl.ExprFunc[K], error) {
 	return func(ctx context.Context, tCtx K) (any, error) {
 		val, err := target.Get(ctx, tCtx)
 		if err != nil {
 			return nil, err
 		}
 
 		switch version {
-		case v32:
+		case v32Hash:
 			h := murmur3.Sum32([]byte(val))
-			b := make([]byte, 4)
-			binary.LittleEndian.PutUint32(b, h)
-			return hex.EncodeToString(b), nil
-		case v128:
+			return int64(h), nil
+		case v128Hash:
 			h1, h2 := murmur3.Sum128([]byte(val))
-			b := make([]byte, 16)
-			binary.LittleEndian.PutUint64(b[:8], h1)
-			binary.LittleEndian.PutUint64(b[8:], h2)
-			return hex.EncodeToString(b), nil
+			return []int64{int64(h1), int64(h2)}, nil
+		case v32Hex, v128Hex:
+			return hexStringLittleEndianVariant(val, version)
 		default:
 			return nil, fmt.Errorf("invalid argument: %s", version)
 		}
 	}, nil
 }
+
+// hexStringLittleEndianVariant returns the hexadecimal representation of the hash in little-endian format.
+// MurmurHash3, developed by Austin Appleby, is sensitive to endianness. Other languages like Python, Ruby,
+// and Java (using Guava) return a hexadecimal string in the little-endian variant. This function does the same.
+func hexStringLittleEndianVariant(target string, version string) (string, error) {
+	switch version {
+	case v32Hex:
+		h := murmur3.Sum32([]byte(target))
+		b := make([]byte, 4)
+		binary.LittleEndian.PutUint32(b, h)
+		return hex.EncodeToString(b), nil
+	case v128Hex:
+		h1, h2 := murmur3.Sum128([]byte(target))
+		b := make([]byte, 16)
+		binary.LittleEndian.PutUint64(b[:8], h1)
+		binary.LittleEndian.PutUint64(b[8:], h2)
+		return hex.EncodeToString(b), nil
+	default:
+		return "", fmt.Errorf("invalid argument: %s", version)
+	}
+}

pkg/ottl/ottlfuncs/func_murmurhash3_test.go

@@ -17,20 +17,32 @@ func Test_MurmurHash3(t *testing.T) {
 	tests := []struct {
 		name        string
 		oArgs       ottl.Arguments
-		expected    string
+		expected    any
 		createError string
 		funcError   string
 	}{
 		{
-			name: "string",
+			name: "string in v32_hash",
 			oArgs: &MurmurHash3Arguments[any]{
 				Target: ottl.StandardStringGetter[any]{
 					Getter: func(_ context.Context, _ any) (any, error) {
 						return "Hello World", nil
 					},
 				},
+				Version: ottl.NewTestingOptional[string]("v32_hash"),
 			},
-			expected: "dbc2a0c1ab26631a27b4c09fcf1fe683",
+			expected: int64(427197390),
+		},
+		{
+			name: "string in v128_hash",
+			oArgs: &MurmurHash3Arguments[any]{
+				Target: ottl.StandardStringGetter[any]{
+					Getter: func(_ context.Context, _ any) (any, error) {
+						return "Hello World", nil
+					},
+				},
+			},
+			expected: []int64{int64(1901405986810282715), int64(-8942425033498643417)},
 		},
 		{
 			name: "empty string",
@@ -40,31 +52,31 @@ func Test_MurmurHash3(t *testing.T) {
 						return "", nil
 					},
 				},
-				Version: ottl.NewTestingOptional[string]("128"),
+				Version: ottl.NewTestingOptional[string]("v128_hex"),
 			},
 			expected: "00000000000000000000000000000000",
 		},
 		{
-			name: "string in v128",
+			name: "string in v128_hex",
 			oArgs: &MurmurHash3Arguments[any]{
 				Target: ottl.StandardStringGetter[any]{
 					Getter: func(_ context.Context, _ any) (any, error) {
 						return "Hello World", nil
 					},
 				},
-				Version: ottl.NewTestingOptional[string]("128"),
+				Version: ottl.NewTestingOptional[string]("v128_hex"),
 			},
 			expected: "dbc2a0c1ab26631a27b4c09fcf1fe683",
 		},
 		{
-			name: "string in v32",
+			name: "string in v32_hex",
 			oArgs: &MurmurHash3Arguments[any]{
 				Target: ottl.StandardStringGetter[any]{
 					Getter: func(_ context.Context, _ any) (any, error) {
 						return "Hello World", nil
 					},
 				},
-				Version: ottl.NewTestingOptional[string]("32"),
+				Version: ottl.NewTestingOptional[string]("v32_hex"),
 			},
 			expected: "ce837619",
 		},