mongokit: support $mod query operator

Author: 256dpi

mongokit/match.go

@@ -50,6 +50,7 @@ func init() {
 	ExpressionQueryOperators["$bitsAllSet"] = matchBits
 	ExpressionQueryOperators["$bitsAnyClear"] = matchBits
 	ExpressionQueryOperators["$bitsAnySet"] = matchBits
+	ExpressionQueryOperators["$mod"] = matchMod
 }
 
 // Match will test if the specified document matches the supplied MongoDB query
@@ -461,6 +462,89 @@ func matchElem(ctx Context, doc bsonkit.Doc, name, path string, v interface{}) e
 	return ErrNotMatched
 }
 
+func matchMod(_ Context, doc bsonkit.Doc, name, path string, v interface{}) error {
+	// get array
+	array, ok := v.(bson.A)
+	if !ok {
+		return fmt.Errorf("%s: expected array", name)
+	}
+
+	// MongoDB requires exactly two elements: [divisor, remainder]
+	if len(array) != 2 {
+		return fmt.Errorf("%s: expected array of two elements", name)
+	}
+
+	// parse divisor and remainder; doubles are truncated toward zero
+	divisor, err := modOperandToInt64(name, "divisor", array[0])
+	if err != nil {
+		return err
+	}
+	remainder, err := modOperandToInt64(name, "remainder", array[1])
+	if err != nil {
+		return err
+	}
+
+	// reject zero divisor
+	if divisor == 0 {
+		return fmt.Errorf("%s: divisor cannot be zero", name)
+	}
+
+	return matchUnwind(doc, path, true, false, func(field interface{}) error {
+		// non-numeric or non-finite fields do not match
+		n, ok := numberToInt64(field)
+		if !ok {
+			return ErrNotMatched
+		}
+		if n%divisor != remainder {
+			return ErrNotMatched
+		}
+		return nil
+	})
+}
+
+func modOperandToInt64(name, role string, v interface{}) (int64, error) {
+	switch n := v.(type) {
+	case int32:
+		return int64(n), nil
+	case int64:
+		return n, nil
+	case float64:
+		if math.IsNaN(n) {
+			return 0, fmt.Errorf("%s: %s cannot be NaN", name, role)
+		}
+		if math.IsInf(n, 0) {
+			return 0, fmt.Errorf("%s: %s cannot be infinity", name, role)
+		}
+		// reject doubles that fall outside the int64 range; -float64(MinInt64)
+		// is exactly 2^63, the smallest float strictly above MaxInt64
+		if n < float64(math.MinInt64) || n >= -float64(math.MinInt64) {
+			return 0, fmt.Errorf("%s: %s out of range", name, role)
+		}
+		return int64(math.Trunc(n)), nil
+	default:
+		return 0, fmt.Errorf("%s: %s must be a number", name, role)
+	}
+}
+
+func numberToInt64(v interface{}) (int64, bool) {
+	switch n := v.(type) {
+	case int32:
+		return int64(n), true
+	case int64:
+		return n, true
+	case float64:
+		if math.IsNaN(n) || math.IsInf(n, 0) {
+			return 0, false
+		}
+		if n < float64(math.MinInt64) || n >= -float64(math.MinInt64) {
+			return 0, false
+		}
+		return int64(math.Trunc(n)), true
+	default:
+		return 0, false
+	}
+}
+
 func matchBits(_ Context, doc bsonkit.Doc, op, path string, v interface{}) error {
 	// parse the bitmask once into a list of bit positions
 	positions, err := parseBitMask(op, v)

mongokit/match_test.go

@@ -1447,3 +1447,102 @@ func TestMatchBits(t *testing.T) {
 		}, false)
 	})
 }
+
+func TestMatchMod(t *testing.T) {
+	matchTest(t, bson.M{
+		"foo": int32(10),
+	}, func(fn func(bson.M, interface{})) {
+		// invalid argument shapes
+		fn(bson.M{
+			"foo": bson.M{"$mod": int32(1)},
+		}, "$mod: expected array")
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3)}},
+		}, "$mod: expected array of two elements")
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(1), int32(2), int32(3)}},
+		}, "$mod: expected array of two elements")
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{"x", int32(0)}},
+		}, "$mod: divisor must be a number")
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(2), "x"}},
+		}, "$mod: remainder must be a number")
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(0), int32(0)}},
+		}, "$mod: divisor cannot be zero")
+
+		// matching int32 field
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(1)}},
+		}, true)
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(2)}},
+		}, false)
+
+		// int64 / float64 operands are accepted and truncated
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int64(4), int64(2)}},
+		}, true)
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{3.7, 1.9}},
+		}, true) // truncated to (3, 1) → 10 % 3 == 1
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{3.0, 1.0}},
+		}, true)
+	})
+
+	// fractional float field is truncated toward zero
+	matchTest(t, bson.M{
+		"foo": 10.7,
+	}, func(fn func(bson.M, interface{})) {
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(1)}},
+		}, true) // trunc(10.7)=10, 10%3=1
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(2)}},
+		}, false)
+	})
+
+	// negative dividend retains sign of dividend in remainder
+	matchTest(t, bson.M{
+		"foo": int32(-7),
+	}, func(fn func(bson.M, interface{})) {
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(-1)}},
+		}, true)
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(3), int32(2)}},
+		}, false)
+	})
+
+	// non-numeric field never matches
+	matchTest(t, bson.M{
+		"foo": "bar",
+	}, func(fn func(bson.M, interface{})) {
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(1), int32(0)}},
+		}, false)
+	})
+
+	// missing field never matches
+	matchTest(t, bson.M{
+		"foo": int32(1),
+	}, func(fn func(bson.M, interface{})) {
+		fn(bson.M{
+			"bar": bson.M{"$mod": bson.A{int32(1), int32(0)}},
+		}, false)
+	})
+
+	// array field unwinds: matches if any element matches
+	matchTest(t, bson.M{
+		"foo": bson.A{int32(3), int32(7), int32(10)},
+	}, func(fn func(bson.M, interface{})) {
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(5), int32(0)}},
+		}, true) // 10 % 5 == 0
+		fn(bson.M{
+			"foo": bson.M{"$mod": bson.A{int32(5), int32(4)}},
+		}, false)
+	})
+}