CSHARP-516: Support Int64 values when using % operator in LINQ queries.

Author: Robert Stam

Driver/Builders/QueryBuilder.cs

@@ -283,14 +283,23 @@ public static IMongoQuery Matches(string name, BsonRegularExpression regex)
  /// <param name="modulus">The modulus.</param>
  /// <param name="value">The value.</param>
  /// <returns>An IMongoQuery.</returns>
- public static IMongoQuery Mod(string name, int modulus, int value)
+ public static IMongoQuery Mod(string name, long modulus, long value)
  {
  if (name == null)
  {
  throw new ArgumentNullException("name");
  }
 
- var condition = new BsonDocument("$mod", new BsonArray { modulus, value });
+ BsonDocument condition;
+ if (modulus >= int.MinValue && modulus <= int.MaxValue &&
+ value >= int.MinValue && value <= int.MaxValue)
+ {
+ condition = new BsonDocument("$mod", new BsonArray { (int)modulus, (int)value });
+ }
+ else
+ {
+ condition = new BsonDocument("$mod", new BsonArray { modulus, value });
+ }
  return new QueryDocument(name, condition);
  }
 

Driver/Builders/QueryBuilderTyped.cs

@@ -241,7 +241,7 @@ public static IMongoQuery Matches(Expression<Func<TDocument, IEnumerable<string>
  /// <param name="modulus">The modulus.</param>
  /// <param name="value">The value.</param>
  /// <returns>An IMongoQuery.</returns>
- public static IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression, int modulus, int value)
+ public static IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression, long modulus, long value)
  {
  return new QueryBuilder<TDocument>().Mod(memberExpression, modulus, value);
  }
@@ -253,7 +253,7 @@ public static IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression,
  /// <param name="modulus">The modulus.</param>
  /// <param name="value">The value.</param>
  /// <returns>An IMongoQuery.</returns>
- public static IMongoQuery Mod(Expression<Func<TDocument, IEnumerable<int>>> memberExpression, int modulus, int value)
+ public static IMongoQuery Mod(Expression<Func<TDocument, IEnumerable<int>>> memberExpression, long modulus, long value)
  {
  return new QueryBuilder<TDocument>().Mod(memberExpression, modulus, value);
  }
@@ -873,7 +873,7 @@ public IMongoQuery Matches(Expression<Func<TDocument, IEnumerable<string>>> memb
  /// <param name="modulus">The modulus.</param>
  /// <param name="value">The value.</param>
  /// <returns>An IMongoQuery.</returns>
- public IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression, int modulus, int value)
+ public IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression, long modulus, long value)
  {
  if (memberExpression == null)
  {
@@ -891,7 +891,7 @@ public IMongoQuery Mod(Expression<Func<TDocument, int>> memberExpression, int mo
  /// <param name="modulus">The modulus.</param>
  /// <param name="value">The value.</param>
  /// <returns>An IMongoQuery.</returns>
- public IMongoQuery Mod(Expression<Func<TDocument, IEnumerable<int>>> memberExpression, int modulus, int value)
+ public IMongoQuery Mod(Expression<Func<TDocument, IEnumerable<int>>> memberExpression, long modulus, long value)
  {
  if (memberExpression == null)
  {

Driver/Linq/Translators/PredicateTranslator.cs

@@ -755,11 +755,11 @@ private IMongoQuery BuildModQuery(Expression variableExpression, ExpressionType
  return null;
  }
 
- if (constantExpression.Type != typeof(int))
+ if (constantExpression.Type != typeof(int) && constantExpression.Type != typeof(long))
  {
  return null;
  }
- var value = ToInt32(constantExpression);
+ var value = ToInt64(constantExpression);
 
  var modBinaryExpression = variableExpression as BinaryExpression;
  if (modBinaryExpression != null && modBinaryExpression.NodeType == ExpressionType.Modulo)
@@ -768,7 +768,7 @@ private IMongoQuery BuildModQuery(Expression variableExpression, ExpressionType
  var modulusExpression = modBinaryExpression.Right as ConstantExpression;
  if (modulusExpression != null)
  {
- var modulus = ToInt32(modulusExpression);
+ var modulus = ToInt64(modulusExpression);
  if (operatorType == ExpressionType.Equal)
  {
  return Query.Mod(serializationInfo.ElementName, modulus, value);
@@ -1390,5 +1390,28 @@ private int ToInt32(Expression expression)
 
  return (int)constantExpression.Value;
  }
+
+ private long ToInt64(Expression expression)
+ {
+ if (expression.Type != typeof(int) && expression.Type != typeof(long))
+ {
+ throw new ArgumentOutOfRangeException("expression", "Expected an Expression of Type Int32 or Int64.");
+ }
+
+ var constantExpression = expression as ConstantExpression;
+ if (constantExpression == null)
+ {
+ throw new ArgumentOutOfRangeException("expression", "Expected a ConstantExpression.");
+ }
+
+ if (expression.Type == typeof(int))
+ {
+ return (long)(int)constantExpression.Value;
+ }
+ else
+ {
+ return (long)constantExpression.Value;
+ }
+ }
  }
 }

DriverUnitTests/Linq/SelectQueryTests.cs

@@ -43,6 +43,8 @@ public class C
  public ObjectId Id { get; set; }
  [BsonElement("x")]
  public int X { get; set; }
+ [BsonElement("lx")]
+ public long LX { get; set; }
  [BsonElement("y")]
  public int Y { get; set; }
  [BsonElement("d")]
@@ -150,11 +152,11 @@ public void Setup()
 
  // documents inserted deliberately out of order to test sorting
  _collection.Drop();
- _collection.Insert(new C { Id = _id2, X = 2, Y = 11, D = new D { Z = 22 }, A = new [] { 2, 3, 4 }, DA = new List<D> { new D { Z = 111 }, new D { Z = 222 } }, L = new List<int> { 2, 3, 4 } });
- _collection.Insert(new C { Id = _id1, X = 1, Y = 11, D = new D { Z = 11 }, S = "abc", SA = new string[] { "Tom", "Dick", "Harry" } });
- _collection.Insert(new C { Id = _id3, X = 3, Y = 33, D = new D { Z = 33 }, B = true, BA = new bool[] { true }, E = E.A, EA = new E[] { E.A, E.B } });
- _collection.Insert(new C { Id = _id5, X = 5, Y = 44, D = new D { Z = 55 }, DBRef = new MongoDBRef("db", "c", 1) });
- _collection.Insert(new C { Id = _id4, X = 4, Y = 44, D = new D { Z = 44 }, S = " xyz ", DA = new List<D> { new D { Z = 333 }, new D { Z = 444 } } });
+ _collection.Insert(new C { Id = _id2, X = 2, LX = 2, Y = 11, D = new D { Z = 22 }, A = new[] { 2, 3, 4 }, DA = new List<D> { new D { Z = 111 }, new D { Z = 222 } }, L = new List<int> { 2, 3, 4 } });
+ _collection.Insert(new C { Id = _id1, X = 1, LX = 1, Y = 11, D = new D { Z = 11 }, S = "abc", SA = new string[] { "Tom", "Dick", "Harry" } });
+ _collection.Insert(new C { Id = _id3, X = 3, LX = 3, Y = 33, D = new D { Z = 33 }, B = true, BA = new bool[] { true }, E = E.A, EA = new E[] { E.A, E.B } });
+ _collection.Insert(new C { Id = _id5, X = 5, LX = 5, Y = 44, D = new D { Z = 55 }, DBRef = new MongoDBRef("db", "c", 1) });
+ _collection.Insert(new C { Id = _id4, X = 4, LX = 4, Y = 44, D = new D { Z = 44 }, S = " xyz ", DA = new List<D> { new D { Z = 333 }, new D { Z = 444 } } });
  }
 
  [Test]
@@ -4046,6 +4048,121 @@ public void TestWhereLSub1NotEquals3Not()
  Assert.AreEqual(1, Consume(query));
  }
 
+ [Test]
+ public void TestWhereLXModTwoEquals1()
+ {
+ var query = from c in _collection.AsQueryable<C>()
+ where c.LX % 2 == 1
+ select c;
+
+ var translatedQuery = MongoQueryTranslator.Translate(query);
+ Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+ Assert.AreSame(_collection, translatedQuery.Collection);
+ Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+ var selectQuery = (SelectQuery)translatedQuery;
+ Assert.AreEqual("(C c) => ((c.LX % 2) == 1)", ExpressionFormatter.ToString(selectQuery.Where));
+ Assert.IsNull(selectQuery.OrderBy);
+ Assert.IsNull(selectQuery.Projection);
+ Assert.IsNull(selectQuery.Skip);
+ Assert.IsNull(selectQuery.Take);
+
+ Assert.AreEqual("{ \"lx\" : { \"$mod\" : [2, 1] } }", selectQuery.BuildQuery().ToJson());
+ Assert.AreEqual(3, Consume(query));
+ }
+
+ [Test]
+ public void TestWhereLXModTwoEquals1Not()
+ {
+ var query = from c in _collection.AsQueryable<C>()
+ where !(c.LX % 2 == 1)
+ select c;
+
+ var translatedQuery = MongoQueryTranslator.Translate(query);
+ Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+ Assert.AreSame(_collection, translatedQuery.Collection);
+ Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+ var selectQuery = (SelectQuery)translatedQuery;
+ Assert.AreEqual("(C c) => !((c.LX % 2) == 1)", ExpressionFormatter.ToString(selectQuery.Where));
+ Assert.IsNull(selectQuery.OrderBy);
+ Assert.IsNull(selectQuery.Projection);
+ Assert.IsNull(selectQuery.Skip);
+ Assert.IsNull(selectQuery.Take);
+
+ Assert.AreEqual("{ \"lx\" : { \"$not\" : { \"$mod\" : [2, 1] } } }", selectQuery.BuildQuery().ToJson());
+ Assert.AreEqual(2, Consume(query));
+ }
+
+ [Test]
+ public void TestWhereLXModTwoEquals1Reversed()
+ {
+ var query = from c in _collection.AsQueryable<C>()
+ where 1 == c.LX % 2
+ select c;
+
+ var translatedQuery = MongoQueryTranslator.Translate(query);
+ Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+ Assert.AreSame(_collection, translatedQuery.Collection);
+ Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+ var selectQuery = (SelectQuery)translatedQuery;
+ Assert.AreEqual("(C c) => ((c.LX % 2) == 1)", ExpressionFormatter.ToString(selectQuery.Where));
+ Assert.IsNull(selectQuery.OrderBy);
+ Assert.IsNull(selectQuery.Projection);
+ Assert.IsNull(selectQuery.Skip);
+ Assert.IsNull(selectQuery.Take);
+
+ Assert.AreEqual("{ \"lx\" : { \"$mod\" : [2, 1] } }", selectQuery.BuildQuery().ToJson());
+ Assert.AreEqual(3, Consume(query));
+ }
+
+ [Test]
+ public void TestWhereLXModTwoNotEquals1()
+ {
+ var query = from c in _collection.AsQueryable<C>()
+ where c.LX % 2 != 1
+ select c;
+
+ var translatedQuery = MongoQueryTranslator.Translate(query);
+ Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+ Assert.AreSame(_collection, translatedQuery.Collection);
+ Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+ var selectQuery = (SelectQuery)translatedQuery;
+ Assert.AreEqual("(C c) => ((c.LX % 2) != 1)", ExpressionFormatter.ToString(selectQuery.Where));
+ Assert.IsNull(selectQuery.OrderBy);
+ Assert.IsNull(selectQuery.Projection);
+ Assert.IsNull(selectQuery.Skip);
+ Assert.IsNull(selectQuery.Take);
+
+ Assert.AreEqual("{ \"lx\" : { \"$not\" : { \"$mod\" : [2, 1] } } }", selectQuery.BuildQuery().ToJson());
+ Assert.AreEqual(2, Consume(query));
+ }
+
+ [Test]
+ public void TestWhereLXModTwoNotEquals1Not()
+ {
+ var query = from c in _collection.AsQueryable<C>()
+ where !(c.LX % 2 != 1)
+ select c;
+
+ var translatedQuery = MongoQueryTranslator.Translate(query);
+ Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+ Assert.AreSame(_collection, translatedQuery.Collection);
+ Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+ var selectQuery = (SelectQuery)translatedQuery;
+ Assert.AreEqual("(C c) => !((c.LX % 2) != 1)", ExpressionFormatter.ToString(selectQuery.Where));
+ Assert.IsNull(selectQuery.OrderBy);
+ Assert.IsNull(selectQuery.Projection);
+ Assert.IsNull(selectQuery.Skip);
+ Assert.IsNull(selectQuery.Take);
+
+ Assert.AreEqual("{ \"lx\" : { \"$mod\" : [2, 1] } }", selectQuery.BuildQuery().ToJson());
+ Assert.AreEqual(3, Consume(query));
+ }
+
  [Test]
  public void TestWhereSASub0ContainsO()
  {