public void TestAggregateFunctions() { LoadModelNumbers(100); var queryable = new DatabaseQueryable <NumbersModel>(Db); var result = (from x in queryable select x.Number1).Average(); result.Should().BeApproximately(50.5, Double.Epsilon); queryable = new DatabaseQueryable <NumbersModel>(Db); result = (from x in queryable select x.Number1).Count(); result.Should().Be(100); queryable = new DatabaseQueryable <NumbersModel>(Db); result = (from x in queryable select x.Number1).Min(); result.Should().Be(1); queryable = new DatabaseQueryable <NumbersModel>(Db); result = (from x in queryable select x.Number1).Max(); result.Should().Be(100); queryable = new DatabaseQueryable <NumbersModel>(Db); result = (from x in queryable select x.Number1).Sum(); result.Should().Be(5050); }
public void TestSelectDistinct() { var doc1 = new SimpleModel { Age = 1 }; Db.Save(doc1); var doc2 = new SimpleModel { Age = 1 }; Db.Save(doc2); var queryable = new DatabaseQueryable <SimpleModel>(Db); var q = (from x in queryable select x.Age).Distinct(); var numRows = VerifyQuery(q, (n, row) => { var number = row; number.Should().Be(1); }); numRows.Should().Be(1, "because there is only one distinct row"); }
public void TestWhereRegex() { LoadJSONResource("names_100"); var regex = new Regex("^Mar.*"); var queryable = new DatabaseQueryable <NamesModel>(Db); var q = from x in queryable where regex.IsMatch(x.Name.First) orderby x.Name.First select x.Name.First; var firstNames = new List <string>(); var numRows = VerifyQuery(q, (n, row) => { var firstName = row; if (firstName != null) { firstNames.Add(firstName); } }); numRows.Should().Be(5, "because there are 5 rows like that in the data source"); firstNames.Should() .OnlyContain(str => regex.IsMatch(str), "because otherwise an incorrect entry came in"); }
public void TestWhereIs() { using (var doc1 = new SimpleModel { Name = "string" }) { Db.Save(doc1); } var queryable = new DatabaseQueryable <SimpleModel>(Db); var q = from x in queryable where x.Name == "string" select x.Id(); var numRows = VerifyQuery(q, (n, row) => { using (var doc = Db.GetDocument(row).ToModel <SimpleModel>()) { doc.Name.Should().Be("string"); } }); numRows.Should().Be(1, "beacuse one row matches the given query"); q = from x in queryable where x.Name != "string1" select x.Id(); numRows = VerifyQuery(q, (n, row) => { using (var doc = Db.GetDocument(row).ToModel <SimpleModel>()) { doc.Name.Should().Be("string"); } }); numRows.Should().Be(1, "because one row matches the 'IS NOT' query"); }
public void TestLimit() { LoadModelNumbers(10); var queryable = new DatabaseQueryable <NumbersModel>(Db); var q = (from x in queryable orderby x.Number1 select x.Number1).Take(5); var expectedNumbers = new[] { 1, 2, 3, 4, 5 }; var numRows = VerifyQuery(q, (n, row) => { row.Should().Be(expectedNumbers[n - 1]); }); }
public void TestOrderBy() { LoadJSONResource("names_100"); foreach (var ascending in new[] { true, false }) { var queryable = new DatabaseQueryable <NamesModel>(Db); IQueryable <string> q = null; if (ascending) { q = from x in queryable orderby x.Name.First select x.Name.First; } else { q = from x in queryable orderby x.Name.First descending select x.Name.First; } var firstNames = new List <object>(); var numRows = VerifyQuery(q, (n, row) => { var firstName = row; if (firstName != null) { firstNames.Add(firstName); } }); numRows.Should().Be(100, "because otherwise the wrong number of rows was retrieved"); firstNames.Should().HaveCount(numRows, "because otherwise some rows were null"); var firstNamesCopy = new List <object>(firstNames); firstNames.Sort(); if (!ascending) { firstNames.Reverse(); } firstNames.Should().ContainInOrder(firstNamesCopy, "because otherwise the results were not sorted"); } }
public void TestWhereIn() { LoadJSONResource("names_100"); var expected = new[] { "Marcy", "Margaretta", "Margrett", "Marlen", "Maryjo" }; var queryable = new DatabaseQueryable <NamesModel>(Db); var q = from x in queryable where expected.Contains(x.Name.First) orderby x.Name.First select x.Name.First; var numRows = VerifyQuery(q, (n, row) => { var name = row; name.Should().Be(expected[n - 1], "because otherwise incorrect rows were returned"); }); numRows.Should().Be(expected.Length, "because otherwise an incorrect number of rows were returned"); }
public void TestMathFunctions() { const double num = 0.6; var model = new DoubleModel { Number = num, Document = new MutableDocument("doc1") }; Db.Save(model); var expectedValues = new[] { Math.Abs(num), Math.Acos(num), Math.Asin(num), Math.Atan(num), Math.Ceiling(num), Math.Exp(num), Math.Floor(num), Math.Log(num), Math.Log10(num), Math.Round(num), Math.Sin(num), Math.Sqrt(num), Math.Tan(num), Math.Truncate(num) }; int index = 0; var queryable = new DatabaseQueryable <DoubleModel>(Db); var parameter = LinqExpression.Parameter(typeof(DoubleModel), "x"); foreach (var function in new[] { "Abs", "Acos", "Asin", "Atan", "Ceiling", "Exp", "Floor", "Log", "Log10", "Round", "Sin", "Sqrt", "Tan", "Truncate" }) { var methodCall = LinqExpression.Lambda <Func <DoubleModel, double> >(LinqExpression.Call(typeof(Math).GetMethod(function, new[] { typeof(double) }), LinqExpression.Property(parameter, "Number")), parameter); var q = queryable.Select(methodCall); var numRows = VerifyQuery(q, (n, r) => { r.Should().Be(expectedValues[index++]); }); numRows.Should().Be(1); } }
public void TestJoin() { LoadModelNumbers(100); var testModel = new JoinedNumbersModel { TheOne = 42, Document = new MutableDocument("joinme") }; Db.Save(testModel); var queryable = new DatabaseQueryable <NumbersModel>(Db); var secondQueryable = new DatabaseQueryable <JoinedNumbersModel>(Db); var q = from x in queryable from y in secondQueryable join secondary in secondQueryable on x.Number1 equals secondary.TheOne select x.Number2; q.Should().HaveCount(1); q.First().Should().Be(58); }
private void RunTestWithNumbers(IList <int> expectedResultCount, IList <Tuple <LinqExpression, Func <NumbersModel, object, bool>, object, ParameterExpression> > validator) { int index = 0; var queryable = new DatabaseQueryable <NumbersModel>(Db); foreach (var c in validator) { var q = queryable.Where(LinqExpression.Lambda <Func <NumbersModel, bool> >(c.Item1, c.Item4)).Select(x => x.Id()); var lastN = 0; VerifyQuery(q, (n, row) => { var doc = Db.GetDocument(row).ToModel <NumbersModel>(); c.Item2(doc, c.Item3).Should().BeTrue("because otherwise the row failed validation"); lastN = n; }); lastN.Should() .Be(expectedResultCount[index++], "because otherwise there was an incorrect number of rows"); } }
public void TestArrayFunctions() { var model = new NamesModel { Contact = new Contact { Phone = new List <string> { "650-123-0001", "650-123-0002" } }, Document = new MutableDocument("doc1") }; Db.Save(model); var queryable = new DatabaseQueryable <NamesModel>(Db); var q = from x in queryable select x.Contact.Phone.Count; var numRows = VerifyQuery(q, (n, r) => { r.Should().Be(2); }); var q2 = from x in queryable select new { TrueVal = x.Contact.Phone.Contains("650-123-0001"), FalseVal = x.Contact.Phone.Contains("650-123-0003") }; numRows = VerifyQuery(q2, (n, r) => { r.TrueVal.Should().BeTrue(); r.FalseVal.Should().BeFalse(); }); numRows.Should().Be(1); }
public void TestWhereLike() { LoadJSONResource("names_100"); var queryable = new DatabaseQueryable <NamesModel>(Db); var q = from x in queryable where x.Name.First.Like("%Mar%") orderby x.Name.First ascending select x.Name.First; var firstNames = new List <string>(); var numRows = VerifyQuery(q, (n, row) => { var firstName = row; if (firstName != null) { firstNames.Add(firstName); } }); numRows.Should().Be(5, "because there are 5 rows like that in the data source"); firstNames.Should() .OnlyContain(str => str.Contains("Mar"), "because otherwise an incorrect entry came in"); }