f#查询表达式生成

Question

我正在学习F#，现在正在阅读与SQL类型提供程序一起使用的计算表达式和查询表达式。我正在做一些简单的任务，在某些时候需要连接(Union) 2个查询，我的第一个想法，在阅读了序列和列表中的yield之后，在查询表达式中做同样的事情，像这样:

query {
    yield! for a in db.As select { // projection }
    yield! for b in db.Bs select { // projection }
}

这是无效的代码，然后我的第二种方法是使用'concat'它们:

seq {
    yield! query {...}
    yield! query {...}
}

或使用Linq的Concat函数，如:(query {...}).Concat(query {...})。如何做到这一点来自于这个问题的答案

以上两种方法都有一个区别，使用seq将运行2个SQL查询，而Concat只运行一个，这是可以理解的。

我的问题是:为什么查询表达式不支持yield ?

---

编辑:

经过进一步的调查，我得到了MSDN文档，我看到了Yield和YieldFrom方法的实现，但没有Combine和Delay方法，这对我来说现在更令人困惑

Answer 1

在查询中一定程度上支持

yield!，并且可以在select通常使用的地方使用:

query { 
    for x in [5;2;0].AsQueryable() do 
    where (x > 1)
    sortBy x
    yield! [x; x-1] 
 } |> Seq.toList // [2;1;5;4]

但是，通常不能随意地将查询和顺序操作穿插在一起，因为很难定义它们应该如何组合:

query {
    for x in [1;2;3] do
    where (x > 1)
    while true do // error: can't use while (what would it mean?)
    sortBy x 
}

同样

:

query {
    for x in [1;2;3] do
    where (x > 1)
    sortBy x 
    yield! ['a';'b';'c']
    yield! ['x';'y';'z'] // error
}        

这有点模棱两可，因为不清楚第二个yield!是在for循环内还是在后面附加了一组元素。

所以最好把查询看作查询，把序列看作序列，尽管这两种计算表达式支持一些相同的操作。

一般来说，查询自定义操作符是按元素处理的，所以表达联合或连接之类的东西是很尴尬的，因为它们处理的是整个集合而不是单个元素。但是，如果您愿意，您可以创建一个查询构建器，该构建器添加了一个接受序列的concat自定义操作符，尽管它可能感觉有点不对称:

open System.Linq
type QB() =
    member inline x.Yield v = (Seq.singleton v).AsQueryable()
    member inline x.YieldFrom q = q
    [<CustomOperation("where", MaintainsVariableSpace=true)>]
    member x.Where(q:IQueryable<_>, [<ProjectionParameter>]c:Expressions.Expression<System.Func<_,_>>) = q.Where(c)
    [<CustomOperation("sortBy", MaintainsVariableSpace=true)>]
    member x.SortBy(q:IQueryable<_>, [<ProjectionParameter>]c:Expressions.Expression<System.Func<_,_>>) = q.OrderBy(c)
    [<CustomOperation("select")>]
    member x.Select(q:IQueryable<_>, [<ProjectionParameter>]c:Expressions.Expression<System.Func<_,_>>) = q.Select(c)
    [<CustomOperation("concat")>]
    member x.Concat(q:IQueryable<_>, q') = q.Concat(q')
    member x.For(q:IQueryable<'t>, c:'t->IQueryable<'u>) = q.SelectMany(fun t -> c t :> seq<_>) // TODO: implement something more reasonable here
let qb = QB()
qb {
    for x in ([5;2;0].AsQueryable()) do
    where (x > 1)
    sortBy x
    select x
    concat ([7;8;9].AsQueryable())
} |> Seq.toList

Answer 2

这是f#中查询表达式的极好参考:https://msdn.microsoft.com/en-us/library/hh225374.aspx

特别是，我认为下面的例子从那页做你想要的:

let query1 = query {
        for n in db.Student do
        select (n.Name, n.Age)
    }
let query2 = query {
        for n in db.LastStudent do
        select (n.Name, n.Age)
        }
query2.Union (query1)