public virtual Task Join_select_many(bool async)
{
return(AssertQuery(
async,
ss => from c in ss.Set <Customer>()
join o in ss.Set <Order>() on c.CustomerID equals o.CustomerID
from e in ss.Set <Employee>()
select new
{
c,
o,
e
},
e => (e.c.CustomerID, e.o.OrderID, e.e.EmployeeID),
entryCount: 928));
}
public virtual Task Join_with_skip_navigation(bool async)
{
return(AssertQuery(
async,
ss => from t in ss.Set <EntityTwo>()
join s in ss.Set <EntityTwo>()
on t.Id equals s.SelfSkipSharedRight.OrderBy(e => e.Id).FirstOrDefault().Id
select new { t, s },
elementSorter: e => (e.t.Id, e.s.Id),
elementAsserter: (e, a) =>
{
AssertEqual(e.t, a.t);
AssertEqual(e.s, a.s);
},
entryCount: 18));
}
public virtual Task Client_Join_select_many(bool isAsync)
{
return(AssertQuery(
isAsync,
ss => from e1 in ss.Set <Employee>().OrderBy(e => e.EmployeeID).Take(2)
join e2 in ss.Set <Employee>().OrderBy(e => e.EmployeeID).Take(2) on e1.EmployeeID equals GetEmployeeID(e2)
from e3 in ss.Set <Employee>().OrderBy(e => e.EmployeeID).Skip(6).Take(2)
select new
{
e1,
e2,
e3
},
e => (e.e1.EmployeeID, e.e2.EmployeeID, e.e3.EmployeeID),
entryCount: 4));
}
public virtual Task String_ends_with_not_equals_nullable_column(bool isAsync)
{
return(AssertQuery(
isAsync,
ss => ss.Set <FunkyCustomer>().SelectMany(c => ss.Set <FunkyCustomer>(), (c1, c2) => new { c1, c2 })
.Where(r => r.c1.FirstName.EndsWith(r.c2.LastName) != r.c1.NullableBool.Value),
ss => ss.Set <FunkyCustomer>().SelectMany(c => ss.Set <FunkyCustomer>(), (c1, c2) => new { c1, c2 })
.Where(r => MaybeScalar(r.c1.FirstName, () => MaybeScalar <bool>(r.c2.LastName, () => r.c1.FirstName.EndsWith(r.c2.LastName))) == true
!= MaybeScalar <bool>(r.c1.NullableBool, () => r.c1.NullableBool.Value) == true),
elementSorter: e => (e.c1.Id, e.c2.Id),
elementAsserter: (e, a) =>
{
AssertEqual(e.c1, a.c1);
AssertEqual(e.c2, a.c2);
}));
}
public virtual Task String_ends_with_on_argument_with_wildcard_column(bool async)
{
return(AssertQuery(
async,
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.fn.EndsWith(r.ln)),
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.ln == "" || MaybeScalar(r.fn, () => MaybeScalar <bool>(r.ln, () => r.fn.EndsWith(r.ln))) == true),
elementSorter: e => (e.fn, e.ln),
elementAsserter: (e, a) =>
{
Assert.Equal(e.fn, a.fn);
Assert.Equal(e.ln, a.ln);
}));
}
public virtual Task GroupJoin_subquery_projection_outer_mixed(bool async)
{
return(AssertQuery(
async,
ss =>
from c in ss.Set <Customer>()
from o0 in ss.Set <Order>().OrderBy(o => o.OrderID).Take(1)
join o1 in ss.Set <Order>() on c.CustomerID equals o1.CustomerID into orders
from o2 in orders
select new
{
A = c.CustomerID,
B = o0.CustomerID,
C = o2.CustomerID
},
e => (e.A, e.B, e.C)));
}
public override Task Include_duplicate_collection_result_operator(bool async)
{
// The order of `Orders` can be different, becaues it is not explicitly sorted.
// This is the case on MariaDB.
return(AssertQuery(
async,
ss => (from c1 in ss.Set <Customer>().Include(c => c.Orders).OrderBy(c => c.CustomerID).ThenBy(c => c.Orders.FirstOrDefault() != null ? c.Orders.FirstOrDefault().CustomerID : null).Take(2)
from c2 in ss.Set <Customer>().Include(c => c.Orders).OrderBy(c => c.CustomerID).ThenBy(c => c.Orders.FirstOrDefault() != null ? c.Orders.FirstOrDefault().CustomerID : null).Skip(2).Take(2)
select new { c1, c2 }).OrderBy(t => t.c1.CustomerID).ThenBy(t => t.c2.CustomerID).Take(1),
elementSorter: e => (e.c1.CustomerID, e.c2.CustomerID),
elementAsserter: (e, a) =>
{
AssertInclude(e.c1, a.c1, new ExpectedInclude <Customer>(c => c.Orders));
AssertInclude(e.c2, a.c2, new ExpectedInclude <Customer>(c => c.Orders));
},
entryCount: 15));
}
public virtual Task String_ends_with_inside_conditional(bool isAsync)
{
return(AssertQuery <FunkyCustomer>(
isAsync,
fcs => fcs.Select(c => c.FirstName)
.SelectMany(c => fcs.Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.fn.EndsWith(r.ln) ? true : false),
fcs => fcs.Select(c => c.FirstName)
.SelectMany(c => fcs.Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.ln == "" || MaybeScalar(r.fn, () => MaybeScalar <bool>(r.ln, () => r.fn.EndsWith(r.ln))) == true ? true : false),
elementSorter: e => (e.fn, e.ln),
elementAsserter: (e, a) =>
{
Assert.Equal(e.fn, a.fn);
Assert.Equal(e.ln, a.ln);
}));
}
public virtual Task String_ends_with_inside_conditional(bool async)
{
return(AssertQuery(
async,
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.fn.EndsWith(r.ln) ? true : false),
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.ln == "" || r.fn.EndsWith(r.ln) ? true : false),
elementSorter: e => (e.fn, e.ln),
elementAsserter: (e, a) =>
{
Assert.Equal(e.fn, a.fn);
Assert.Equal(e.ln, a.ln);
}));
}
public virtual Task String_contains_on_argument_with_wildcard_column(bool async)
{
return(AssertQuery(
async,
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.fn.Contains(r.ln)),
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.ln == "" || r.fn.Contains(r.ln)),
elementSorter: e => (e.fn, e.ln),
elementAsserter: (e, a) =>
{
Assert.Equal(e.fn, a.fn);
Assert.Equal(e.ln, a.ln);
}));
}
public override async Task KeylessEntity_with_mixed_tracking(bool isAsync)
{
await AssertQuery(
isAsync,
ss => from c in ss.Set <Customer>().Where(ct => ct.City == "London")
from o in ss.Set <OrderQuery>().Where(ov => ov.CustomerID == c.CustomerID)
select new { c, o },
elementSorter : e => (e.c.CustomerID, e.o.CustomerID),
elementAsserter : (e, a) =>
{
AssertEqual(e.c, a.c);
AssertEqual(e.o, a.o);
});
AssertSql(
@"SELECT c
FROM root c
WHERE ((c[""Discriminator""] = ""Customer"") AND (c[""City""] = ""London""))");
}
public virtual Task GroupJoin_DefaultIfEmpty_multiple(bool async)
{
return(AssertQuery(
async,
ss =>
from c in ss.Set <Customer>().Where(c => c.CustomerID.StartsWith("F"))
join o1 in ss.Set <Order>() on c.CustomerID equals o1.CustomerID into orders1
from o1 in orders1.DefaultIfEmpty()
join o2 in ss.Set <Order>() on c.CustomerID equals o2.CustomerID into orders2
from o2 in orders2.DefaultIfEmpty()
select new
{
c,
o1,
o2
},
e => (e.c.CustomerID, e.o1?.OrderID, e.o2?.OrderID),
entryCount: 71));
}
public override Task String_contains_on_argument_with_wildcard_column(bool isAsync)
{
// See https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/996#issuecomment-607844082
return(AssertQuery(
isAsync,
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => r.fn.Contains(r.ln)),
ss => ss.Set <FunkyCustomer>().Select(c => c.FirstName)
.SelectMany(c => ss.Set <FunkyCustomer>().Select(c2 => c2.LastName), (fn, ln) => new { fn, ln })
.Where(r => MaybeScalar(r.fn, () => MaybeScalar <bool>(r.ln, () => r.fn.Contains(r.ln))) == true),
elementSorter: e => (e.fn, e.ln),
elementAsserter: (e, a) =>
{
Assert.Equal(e.fn, a.fn);
Assert.Equal(e.ln, a.ln);
}));
}