GT() public static method

Tests that the value of the named element is greater than some value (see $gt).
public static GT ( string name, BsonValue value ) : QueryConditionList
name string The name of the element to test.
value BsonValue The value to compare to.
return QueryConditionList
        public void TestGreaterThanAndMod()
        {
            var query    = Query.GT("k", 10).Mod(10, 1);
            var expected = "{ \"k\" : { \"$gt\" : 10, \"$mod\" : [10, 1] } }";

            Assert.AreEqual(expected, query.ToJson());
        }
        public void TestGreaterThanAndLessThanOrEqual()
        {
            var query    = Query.GT("k", 10).LTE(20);
            var expected = "{ \"k\" : { \"$gt\" : 10, \"$lte\" : 20 } }";

            Assert.AreEqual(expected, query.ToJson());
        }
        public void TestGreaterThan()
        {
            var query    = Query.GT("k", 10);
            var expected = "{ \"k\" : { \"$gt\" : 10 } }";

            Assert.AreEqual(expected, query.ToJson());
        }
        public void TestNotElemMatch()
        {
            var query    = Query.Not("name").ElemMatch(Query.GT("x", 1));
            var expected = "{ \"name\" : { \"$not\" : { \"$elemMatch\" : { \"x\" : { \"$gt\" : 1 } } } } }";
            JsonWriterSettings settings = new JsonWriterSettings {
                OutputMode = JsonOutputMode.JavaScript
            };
            var actual = query.ToJson(settings);

            Assert.AreEqual(expected, actual);
        }
Example #5
0
        public void TestEq2()
        {
            // now that server supports $and this is actually syntactically valid
            var query = Query.And(
                Query.GT("value", 6),
                Query.EQ("value", 20)
                );
            var expected = "{ '$and' : [{ 'value' : { '$gt' : 6 } }, { 'value' : 20 }] }".Replace("'", "\"");
            var json     = query.ToJson();

            Assert.AreEqual(expected, json);
        }
        public void TestElementMatch()
        {
            var query = Query.ElemMatch("x",
                                        Query.And(
                                            Query.EQ("a", 1),
                                            Query.GT("b", 1)
                                            )
                                        );
            var expected = "{ \"x\" : { \"$elemMatch\" : { \"a\" : 1, \"b\" : { \"$gt\" : 1 } } } }";

            Assert.AreEqual(expected, query.ToJson());
        }
Example #7
0
        public void TestAndGtLt()
        {
            var query = Query.And(
                Query.NotIn("value", 1, 2, 3),
                Query.EQ("OtherValue", 1),
                Query.GT("value", 6),
                Query.LT("value", 20)
                );

            Assert.AreEqual(
                new BsonDocument
            {
                { "value", new BsonDocument
                  {
                      { "$nin", new BsonArray {
                                1, 2, 3
                            } },
                      { "$gt", 6 },
                      { "$lt", 20 }
                  } },
                { "OtherValue", 1 }
            },
                query.ToBsonDocument());
        }