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)); }