public void TestSkipThenTake()
{
var query = _collection.AsQueryable <C>().Skip(5).Take(20);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.AreEqual(5, selectQuery.Skip);
Assert.AreEqual(20, selectQuery.Take);
}
public void TestWhereThenSkipThenTake()
{
var query = _collection.AsQueryable <C>().Where(c => c.X == 10).Skip(10).Take(5);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal(10, selectQuery.Skip);
Assert.Equal(5, selectQuery.Take);
}
public void TestTakeThenTake()
{
var query = _collection.AsQueryable <C>().Take(20).Take(5);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Null(selectQuery.Skip);
Assert.Equal(5, selectQuery.Take);
}
public void TestTakeThenSkipThenTakeWithTooMany()
{
var query = _collection.AsQueryable <C>().Take(20).Skip(10).Take(15);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal(10, selectQuery.Skip);
Assert.Equal(10, selectQuery.Take);
}
public void TestSkipThenTakeThenSkipWithTooMany()
{
var query = _collection.AsQueryable <C>().Skip(5).Take(20).Skip(30);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.IsNull(selectQuery.Skip);
Assert.AreEqual(0, selectQuery.Take);
}
public void TestQueryWithSkipAndTakeHasIndexDocumentHint()
{
var query = __collection.AsQueryable().WithIndex(new BsonDocument("x", 1)).Skip(2).Take(5);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal(new BsonDocument("x", 1), selectQuery.IndexHint.AsBsonDocument);
query = __collection.AsQueryable().Skip(2).Take(5).WithIndex(new BsonDocument("x", 1));
selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal(new BsonDocument("x", 1), selectQuery.IndexHint.AsBsonDocument);
}
public void TestQueryWithSkipAndTakeHasIndexNameHint()
{
var query = __collection.AsQueryable().WithIndex("i").Skip(2).Take(5);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal("i", selectQuery.IndexHint.AsString);
query = __collection.AsQueryable().Skip(2).Take(5).WithIndex("i");
selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.Equal("i", selectQuery.IndexHint.AsString);
}
public void Inject()
{
var query = Query <Rental> .LTE(r => r.Price, 500);
var queryable = new RealEstateContext()
.Rentals.AsQueryable()
.Where(r => query.Inject());
var translated = MongoQueryTranslator.Translate(queryable)
as SelectQuery;
Console.WriteLine(translated.BuildQuery());
}
public void TestSkip()
{
var s = new List <string> {
"one", "two", "three"
};
var list = s.Take(3).Take(5).ToList();
var query = _collection.AsQueryable <C>().Skip(5);
var selectQuery = (SelectQuery)MongoQueryTranslator.Translate(query);
Assert.AreEqual(5, selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
}
public BsonDocument Apply()
{
var queryable = _collection.AsQueryable <TClass>()
.Where(_predicate)
.Select(d => d);
var selectQuery = MongoQueryTranslator.Translate(queryable) as SelectQuery;
var query = selectQuery.BuildQuery();
var document = new BsonDocument();
document.Add("$match", query.ToBsonDocument());
return(document);
}
public void CastTest()
{
var server = MongoServer.Create();
var db = server.GetDatabase("test");
var collection = db.GetCollection <Base>("castTest");
collection.Drop();
var t1 = new T1 {
Id = Guid.NewGuid(), A = "T1.A", B = "T1.B"
};
var t2 = new T2 {
Id = Guid.NewGuid(), A = "T2.A"
};
collection.Insert(t1);
collection.Insert(t2);
var query = from t in collection.AsQueryable()
where t is T1 && ((T1)t).B == "T1.B"
select t;
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(collection, translatedQuery.Collection);
Assert.AreSame(typeof(Base), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.AreEqual("(Base t) => ((t is T1) && ((T1)t.B == \"T1.B\"))", ExpressionFormatter.ToString(selectQuery.Where));
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"_t\" : \"T1\", \"B\" : \"T1.B\" }", selectQuery.BuildQuery().ToString());
var results = query.ToList();
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0], Is.InstanceOf(typeof(T1)));
Assert.That(results[0].A, Is.EqualTo("T1.A"));
}
public void CastTest()
{
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2 && BsonDefaults.GuidRepresentation != GuidRepresentation.Unspecified)
{
var db = LegacyTestConfiguration.Database;
var collection = db.GetCollection <Base>("castTest");
collection.Drop();
var t1 = new T1 {
Id = Guid.NewGuid(), A = "T1.A", B = "T1.B"
};
var t2 = new T2 {
Id = Guid.NewGuid(), A = "T2.A"
};
collection.Insert(t1);
collection.Insert(t2);
var query = from t in collection.AsQueryable()
where t is T1 && ((T1)t).B == "T1.B"
select t;
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsType <SelectQuery>(translatedQuery);
Assert.Same(collection, translatedQuery.Collection);
Assert.Same(typeof(Base), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.Equal("(Base t) => ((t is T1) && ((T1)t.B == \"T1.B\"))", ExpressionFormatter.ToString(selectQuery.Where));
Assert.Null(selectQuery.OrderBy);
Assert.Null(selectQuery.Projection);
Assert.Null(selectQuery.Skip);
Assert.Null(selectQuery.Take);
Assert.Equal("{ \"_t\" : \"T1\", \"B\" : \"T1.B\" }", selectQuery.BuildQuery().ToString());
var results = query.ToList();
Assert.Equal(1, results.Count);
Assert.IsType <T1>(results[0]);
Assert.Equal("T1.A", results[0].A);
}
#pragma warning restore 618
}
/// <summary>
/// 翻译Where部分的Lambda表达式。得到独立的Where部分，用来拼装带Where的删除和更新。
/// </summary>
/// <typeparam name="T">使用条件的类型参数。</typeparam>
/// <param name="where">Where条件表达式。</param>
/// <returns>翻译结果。</returns>
private BsonDocument TranslateWhere <T>(Expression <Func <T, bool> > where) where T : class, new()
{
BsonDocument theWhereDocument;
var collection = MongoDb.GetCollection <T>(GetTableName(typeof(T)));
try
{
var theQurePv = new MongoQueryProvider(collection);
var queryWhere = collection.AsQueryable().Where(where);
//var mongoQuery = queryWhere as MongoQueryable<T>;
var translatedQuery = MongoQueryTranslator.Translate(queryWhere);
var selectQuery = translatedQuery as SelectQuery;
theWhereDocument = collection.AsQueryable().Where(where).ToBsonDocument();
}
catch (Exception ex)
{
throw new Exception("where条件未能正确解析", ex);
}
return(theWhereDocument);
}
public void TestWhereDContainsKeyZ()
{
var query = from c in _collection.AsQueryable<C>()
where c.D.ContainsKey("z")
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.D.ContainsKey(\"z\")", ExpressionFormatter.ToString(selectQuery.Where));
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"D.z\" : { \"$exists\" : true } }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(0, query.ToList().Count());
}
public void TestWhereJContainsKeyX()
{
var query = from c in _collection.AsQueryable<C>()
where c.J.Contains("x")
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.J.Contains(\"x\")", ExpressionFormatter.ToString(selectQuery.Where));
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
var ex = Assert.Throws<NotSupportedException>(() => { selectQuery.BuildQuery(); });
Assert.AreEqual("Contains in a LINQ query is only supported for DictionaryRepresentation ArrayOfDocuments or Document, not ArrayOfArrays.", ex.Message);
}
public void TestOfTypeCWhereCGreaterThan0()
{
var query = _collection.AsQueryable <B>().OfType <C>().Where(c => c.c > 0);
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(_collection, translatedQuery.Collection);
Assert.AreSame(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.AreEqual("(C c) => (LinqToMongo.Inject({ \"_t\" : \"C\" }) && (c.c > 0))", ExpressionFormatter.ToString(selectQuery.Where));
Assert.AreEqual(typeof(C), selectQuery.OfType);
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"_t\" : \"C\", \"c\" : { \"$gt\" : 0 } }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(2, Consume(query));
}
public void TestOfTypeC()
{
var query = _collection.AsQueryable <B>().OfType <C>();
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(_collection, translatedQuery.Collection);
Assert.AreSame(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.AreEqual("(B x) => LinqToMongo.Inject({ \"_t\" : \"C\" })", ExpressionFormatter.ToString(selectQuery.Where));
Assert.AreEqual(typeof(C), selectQuery.OfType);
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"_t\" : \"C\" }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(1, Consume(query)); // should match 2 but for that you need to use the hierarchical discriminator
}
public void TestOfTypeB()
{
var query = _collection.AsQueryable <B>().OfType <B>();
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(_collection, translatedQuery.Collection);
Assert.AreSame(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.IsNull(selectQuery.Where);
Assert.AreEqual(null, selectQuery.OfType); // OfType ignored because <T> was the same as <TDocument>
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.IsNull(selectQuery.BuildQuery());
Assert.AreEqual(3, Consume(query));
}
public void TestOfTypeD()
{
var query = _collection.AsQueryable <B>().OfType <D>();
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(_collection, translatedQuery.Collection);
Assert.AreSame(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.AreEqual("(B x) => LinqToMongo.Inject({ \"_t\" : \"D\" })", ExpressionFormatter.ToString(selectQuery.Where));
Assert.AreEqual(typeof(D), selectQuery.OfType);
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"_t\" : \"D\" }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(1, Consume(query));
}
public void TestWhereBGreaterThan0OfTypeCWhereCGreaterThan0()
{
var query = _collection.AsQueryable <B>().Where(b => b.b > 0).OfType <C>().Where(c => c.c > 0);
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsInstanceOf <SelectQuery>(translatedQuery);
Assert.AreSame(_collection, translatedQuery.Collection);
Assert.AreSame(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.AreEqual("(C c) => (((c.b > 0) && LinqToMongo.Inject({ \"_t\" : \"C\" })) && (c.c > 0))", ExpressionFormatter.ToString(selectQuery.Where));
Assert.AreEqual(typeof(C), selectQuery.OfType);
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"b\" : { \"$gt\" : 0 }, \"_t\" : \"C\", \"c\" : { \"$gt\" : 0 } }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(1, Consume(query)); // should match 2 but for that you need to use the hierarchical discriminator
}
public void TestOfTypeDWithProjection()
{
var query = __collection.AsQueryable <B>().OfType <D>().Select(x => new { A = x.d });
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsType <SelectQuery>(translatedQuery);
Assert.Same(__collection, translatedQuery.Collection);
Assert.Same(typeof(B), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.Equal("(B x) => LinqToMongo.Inject({ \"_t\" : \"D\" })", ExpressionFormatter.ToString(selectQuery.Where));
Assert.Equal(typeof(D), selectQuery.OfType);
Assert.Null(selectQuery.OrderBy);
Assert.NotNull(selectQuery.Projection);
Assert.Equal("(D x) => new __AnonymousType<Int32>(x.d)", ExpressionFormatter.ToString(selectQuery.Projection));
Assert.Null(selectQuery.Skip);
Assert.Null(selectQuery.Take);
Assert.Equal("{ \"_t\" : \"D\" }", selectQuery.BuildQuery().ToJson());
Assert.Equal(1, Consume(query));
}
public void TestWhereXEqualsNull()
{
var query = from c in __collection.AsQueryable <C>()
where c.X == null
select c;
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsType <SelectQuery>(translatedQuery);
Assert.Same(__collection, translatedQuery.Collection);
Assert.Same(typeof(C), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.Equal("(C c) => (c.X == (Nullable<Int32>)null)", ExpressionFormatter.ToString(selectQuery.Where));
Assert.Null(selectQuery.OrderBy);
Assert.Null(selectQuery.Projection);
Assert.Null(selectQuery.Skip);
Assert.Null(selectQuery.Take);
Assert.Equal("{ \"x\" : null }", selectQuery.BuildQuery().ToJson());
Assert.Equal(4, Consume(query));
}
public void TestWhereEEqualsA()
{
var query = from c in _collection.AsQueryable <C>()
where c.E == E.A
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) => ((Nullable<Int32>)c.E == (Nullable<Int32>)1)", ExpressionFormatter.ToString(selectQuery.Where));
Assert.IsNull(selectQuery.OrderBy);
Assert.IsNull(selectQuery.Projection);
Assert.IsNull(selectQuery.Skip);
Assert.IsNull(selectQuery.Take);
Assert.AreEqual("{ \"e\" : \"A\" }", selectQuery.BuildQuery().ToJson());
Assert.AreEqual(1, Consume(query));
}
public void TestWhereIContainsKeyZ()
{
var query = from c in __collection.AsQueryable <C>()
where c.I.Contains("z")
select c;
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsType <SelectQuery>(translatedQuery);
Assert.Same(__collection, translatedQuery.Collection);
Assert.Same(typeof(C), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.Equal("(C c) => c.I.Contains(\"z\")", ExpressionFormatter.ToString(selectQuery.Where));
Assert.Null(selectQuery.OrderBy);
Assert.Null(selectQuery.Projection);
Assert.Null(selectQuery.Skip);
Assert.Null(selectQuery.Take);
Assert.Equal("{ \"I.k\" : \"z\" }", selectQuery.BuildQuery().ToJson());
Assert.Equal(0, query.ToList().Count());
}
public void TestWhereEEqualsA()
{
RequireEnvironment.Check().EnvironmentVariable("MONO"); // Does not pass on Mono 3.2.5. Excluding for now.
var query = from c in __collection.AsQueryable <C>()
where c.E == E.A
select c;
var translatedQuery = MongoQueryTranslator.Translate(query);
Assert.IsType <SelectQuery>(translatedQuery);
Assert.Same(__collection, translatedQuery.Collection);
Assert.Same(typeof(C), translatedQuery.DocumentType);
var selectQuery = (SelectQuery)translatedQuery;
Assert.Equal("(C c) => ((Nullable<Int32>)c.E == (Nullable<Int32>)1)", ExpressionFormatter.ToString(selectQuery.Where));
Assert.Null(selectQuery.OrderBy);
Assert.Null(selectQuery.Projection);
Assert.Null(selectQuery.Skip);
Assert.Null(selectQuery.Take);
Assert.Equal("{ \"e\" : \"A\" }", selectQuery.BuildQuery().ToJson());
Assert.Equal(1, Consume(query));
}
public void TestTakeThenWhereThenSkip()
{
var query = _collection.AsQueryable <C>().Take(20).Where(c => c.X == 10).Skip(30);
Assert.Throws(typeof(NotSupportedException), () => MongoQueryTranslator.Translate(query));
}
