「译」LINQ: Building an IQueryable Provider - Part VI: Nested queries

英文原文是Matt Warren发表在MSDN Blogs的系列文章之一，英文渣渣，翻译不供参考，请直接看原文。

你又以为这个系列已经完成，所以我已经转移到其他阵地上去了吗？因为Select操作工作得非常好，所以你以为前面所讲的就是你构建自己的IQueryable提供程序所需要了解的所有内容了吗？哈！还有很多需要学习的呢，而且，Select操作还是有些漏洞。

Finishing Select

有漏洞？怎么可能？我把你当成从来不会出错的微软大神，但是你却说你给我的是劣质的代码？我把已经把代码复制粘贴到产品里，老板已经说了下周一就启动！你怎么能这么做？（喘气）

放心啦，不是什么严重的漏洞，只是一点小小的缺陷而已。

回想一下，在上篇文章中，我建了四种表达式节点，Table，Column，Select和Projection，它们工作十分良好，不是吗？有漏洞的地方是我没有考虑到所有可以写查询表达式的地方。我考虑到的只是最明显的Projection节点出现在查询表达式树顶的情况。毕竟，因为我只支持Select和Where，所以最后一个操作必定是这两者之一。我的代码就是这样假设的。

这不是问题所在。

问题是Projection节点也有可能出现在选择器表达式里面，例如，看下面的查询。

var query = from c in db.Customers
            select new {
                Name = c.ContactName,
                Orders = from o in db.Orders
                         where o.CustomerID == c.CustomerID
                         select o
            };

我在选择器表达式里面写了一个嵌套查询，这与我们之前写的表格式的查询非常不一样。现在我希望我们的提供程序创建嵌套的对象，每个对象都有一个名字和一个订单的集合。这样的查询要怎么实现？SQL甚至都做不到这一点。即使我彻底不支持这种写法，万一有人真的这么写又会发生什么呢？

额，抛出了一个异常，然而并不是我预想的那个异常，看来代码中的bug比我预想的要多。因为这个可爱的查询在选择器表达式中有一个ProjectionExpression，所以我期望在编译投影器函数的时候会抛出一个异常。我之前说过添加自己的表达式节点是没问题的对吧？理由是只有我们才能看到这些节点，哈，看来是我错了。（实际上抛出来的异常是因为我在构建Projection节点的时候弄错了它们的类型而导致的，这个以后再修复。）

现在假设我已经修复了这个类型异常，我要如何处理这个嵌套的Projection节点呢？我可以捕捉这个异常，然后抛出一个自己的异常，加个道歉声明说不支持嵌套查询。但是这样的话我就不是一个好的LINQ开发者，也享受不到解决这个问题的乐趣了。

所以，让我们继续前进吧。

Nested Queries

我希望能够将嵌套的ProjectionExpression转换为嵌套的查询。SQL实际上也做不到这一点，所以我必须在自己的代码做一些事情以达到这种效果。然而，在这里我并不打算做成一个超级完善的解决方案，我只要能取回数据就够了。

因为投影器函数必须要转换为可执行的代码，所以我得将里面的ProjectionExpression节点给替换成从某个地方获取数据以构建Orders集合的代码。数据不可能来自现有的DataReader，因为它只能保存表格式的结果，因此应该来自另一个DataReader。我真正要做的就是将ProjectionExpression转换成执行的时候返回这个集合的一个函数。

我们好像在之前见过类似的东西？

思考中。。。

对，这或多或少就是我们的提供程序所做的事情。呼，事情好像有点难。提供程序早已通过Execute方法将表达式树转换成了结果序列。我想我已经完成一半了。

所以我需要在之前的ProjectionRow类中添加一个执行嵌套查询的函数，它回调提供程序以执行真正的工作。

下面是ProjectionRow和ProjectionBuilder的代码。

public abstract class ProjectionRow {
    public abstract object GetValue(int index);
    public abstract IEnumerable<E> ExecuteSubQuery<E>(LambdaExpression query);
}

internal class ProjectionBuilder : DbExpressionVisitor {
    ParameterExpression row;
    string rowAlias;
    static MethodInfo miGetValue;
    static MethodInfo miExecuteSubQuery;
    
    internal ProjectionBuilder() {
        if (miGetValue == null) {
            miGetValue = typeof(ProjectionRow).GetMethod("GetValue");
            miExecuteSubQuery = typeof(ProjectionRow).GetMethod("ExecuteSubQuery");
        }
    }

    internal LambdaExpression Build(Expression expression, string alias) {
        this.row = Expression.Parameter(typeof(ProjectionRow), "row");
        this.rowAlias = alias;
        Expression body = this.Visit(expression);
        return Expression.Lambda(body, this.row);
    }

    protected override Expression VisitColumn(ColumnExpression column) {
        if (column.Alias == this.rowAlias) {
            return Expression.Convert(Expression.Call(this.row, miGetValue, Expression.Constant(column.Ordinal)), column.Type);
        }
        return column;
    }

    protected override Expression VisitProjection(ProjectionExpression proj) {
        LambdaExpression subQuery = Expression.Lambda(base.VisitProjection(proj), this.row);
        Type elementType = TypeSystem.GetElementType(subQuery.Body.Type);
        MethodInfo mi = miExecuteSubQuery.MakeGenericMethod(elementType);
        return Expression.Convert(
            Expression.Call(this.row, mi, Expression.Constant(subQuery)),
            proj.Type
        );
    }
}

就像在遇到ColumnExpression时插入GetValue方法调用一样，在遇到ProjectionExpression时也要插入ExecuteSubQuery方法调用。

在base.VisitProjection调用返回之后，投影器表达式中的相应的ColumnExpression已经被替换掉了。我决定将投影器表达式和指向ProjectionRow的参数绑定在一起，刚好有一个类可以做这件事，LambdaExpression，因此我将它作为ExecuteSubQuery方法的参数类型。

注意我是将subQuery作为一个ConstantExpression传进去的，这是为了骗过LambdaExpression.Compile方法，使之注意不到我们自己增加的节点。总之我不想让我们自己增加的节点被编译。

下一个要看的是修改过的ProjectionReader类，当然，Enumerator现在也实现了ExecuteSubQuery方法。

internal class ProjectionReader<T> : IEnumerable<T>, IEnumerable {
    Enumerator enumerator;

    internal ProjectionReader(DbDataReader reader, Func<ProjectionRow, T> projector, IQueryProvider provider) {
        this.enumerator = new Enumerator(reader, projector, provider);
    }

    public IEnumerator<T> GetEnumerator() {
        Enumerator e = this.enumerator;
        if (e == null) {
            throw new InvalidOperationException("Cannot enumerate more than once");
        }
        this.enumerator = null;
        return e;
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return this.GetEnumerator();
    }

    class Enumerator : ProjectionRow, IEnumerator<T>, IEnumerator, IDisposable {
        DbDataReader reader;
        T current;
        Func<ProjectionRow, T> projector;
        IQueryProvider provider;

        internal Enumerator(DbDataReader reader, Func<ProjectionRow, T> projector, IQueryProvider provider) {
            this.reader = reader;
            this.projector = projector;
            this.provider = provider;
        }

        public override object GetValue(int index) {
            if (index >= 0) {
                if (this.reader.IsDBNull(index)) {
                    return null;
                }
                else {
                    return this.reader.GetValue(index);
                }
            }
            throw new IndexOutOfRangeException();
        }

        public override IEnumerable<E> ExecuteSubQuery<E>(LambdaExpression query) {
            ProjectionExpression projection = (ProjectionExpression) new Replacer().Replace(query.Body, query.Parameters[0], Expression.Constant(this));
            projection = (ProjectionExpression) Evaluator.PartialEval(projection, CanEvaluateLocally);
            IEnumerable<E> result = (IEnumerable<E>)this.provider.Execute(projection);
            List<E> list = new List<E>(result);
            if (typeof(IQueryable<E>).IsAssignableFrom(query.Body.Type)) {
                return list.AsQueryable();
            }
            return list;
        }

        private static bool CanEvaluateLocally(Expression expression  {
            if (expression.NodeType == ExpressionType.Parameter ||
                expression.NodeType.IsDbExpression()) {
                return false;
            }
            return true;
        }

        public T Current {
            get { return this.current; }
        }

        object IEnumerator.Current {
            get { return this.current; }
        }

        public bool MoveNext() {
            if (this.reader.Read()) {
                this.current = this.projector(this);
                return true;
            }
            return false;
        }

        public void Reset() {
        }

        public void Dispose() {
            this.reader.Dispose();
        }
    }
}

我在创建ProjectionReader时将provider的实例传了进去，它在下面的ExecuteSubQuery中执行子查询时会用到。

看ExecuteSubQuery方法，hey，那个Replacer.Replace是个什么鬼？

我还没有告诉你这个类是什么，待会会给出它的代码，我们先来解释一下ExecuteSubQuery方法干了什么。我们获得了一个LambdaExpression类型的参数，它的body是内查询原始的ProjectionExpression，parameter是指向当前ProjectionRow的引用。虽然一切都是极好的，但问题是我不能通过回调provider来执行这个表达式，因为所有引用了外层查询（想想Where子句里面的连接条件）的ColumnExpression现在都被替换成了GetValue表达式。

没错，我在内层查询里面引用了外层查询，我不能让这些GetValue继续留在表达式中，因为这样的话子查询在执行的时候会尝试去访问不存在的列，好囧。

思考中。。。

啊哈，想到了！这些GetValue方法要获取的数据其实早就可用，并且近在咫尺，这些数据就在DataReader当前行里面。所以我想做的就是以某种方式将这些表达式的值马上“计算”出来，强制子表达式调用GetValue方法。要是已经有代码来做这件事那就太完美了。

等等，这不正是Evaluator.PartialEval方法的工作吗？当然，但是在这里并不管用。为什么？因为这些表达式引用了ProjectionRow参数，而ParameterExpression又是让Evaluator类不对其进行计算的标志。如果我能去掉这些参数引用，将其替换为指向当前ProjectionRow实例的常量表达式的话，就可以使用Evaluator.PartialEval方法将它们替换为实际的值了。这样一切都好办了。

怎么做呢？我需要一个工具，它查找表达式树中的节点，并将其替换为另一个节点。

下面是Replacer类，它简单地遍历一棵树，寻找一个节点的引用，将其替换为另一个不同节点的引用。

internal class Replacer : DbExpressionVisitor {
    Expression searchFor;
    Expression replaceWith;
    internal Expression Replace(Expression expression, Expression searchFor, Expression replaceWith) {
        this.searchFor = searchFor;
        this.replaceWith = replaceWith;
        return this.Visit(expression);
    }
    protected override Expression Visit(Expression exp) {
        if (exp == this.searchFor) {
            return this.replaceWith;
        }
        return base.Visit(exp);
    }
}

漂亮，我都被自己的机智吓到了。

好了，现在我已经可以将那些讨厌的ProjectionRow参数的引用替换成实际的对象，这就是ExecuteSubQuery方法的第一行所做的事情。然而这仅花了几十行英文就解释清楚了:-)

如我所愿，第二行调用了Execute.PartialEval方法。下一行紧接着又调用了provider来执行子查询！撒花！然后我将结果放到了一个List对象中，最后我有可能还要再将它转成IQueryable。我知道这很奇怪，但是这个原生查询中Orders属性的类型就是IQueryable<Order>，这就是IQueryable查询操作符的工作方式，所以C♯创造了匿名类型以充当成员类型。如果我尝试直接返回list的话，将结果组合到一起的投影器就会报错。幸运的是，已经有了将IEnumerable转换成IQueryable的方法，Queryable.AsQueryable。

哇！这些组件就好像被精妙设计出来的一样，能够完美地协同工作了。

大揭秘：我小小作了个弊。我改了Evaluator类，使它能够识别我自己添加的表达式类型。我知道，我知道，我说过其他人没必要知道它们的存在，但是Evaluator也是我自己的代码，所以我觉得这样并没有问题。我在附件的zip文件中附带了这个小小的修改，在这里我只放出有大修改的代码，那点小修改就不放出来了。

我还得写一个新的CanEvaluateLocally规则以供Evaluator类使用，我得确保它不会将我自己添加的那些节点视为可计算的。

所以让我们来看看DbQueryProvider有什么变化吧。

public class DbQueryProvider : QueryProvider {
    DbConnection connection;
    TextWriter log;

    public DbQueryProvider(DbConnection connection) {
        this.connection = connection;
    }

    public TextWriter Log {
        get { return this.log; }
        set { this.log = value; }
    }

    public override string GetQueryText(Expression expression) {
        return this.Translate(expression).CommandText;
    }

    public override object Execute(Expression expression) {
        return this.Execute(this.Translate(expression));
    }

    private object Execute(TranslateResult query) {
        Delegate projector = query.Projector.Compile();

        if (this.log != null) {
            this.log.WriteLine(query.CommandText);
            this.log.WriteLine();
        }

        DbCommand cmd = this.connection.CreateCommand();
        cmd.CommandText = query.CommandText;
        DbDataReader reader = cmd.ExecuteReader();

        Type elementType = TypeSystem.GetElementType(query.Projector.Body.Type);
        return Activator.CreateInstance(
            typeof(ProjectionReader<>).MakeGenericType(elementType),
            BindingFlags.Instance | BindingFlags.NonPublic, null,
            new object[] { reader, projector, this },
            null
            );
    }

    internal class TranslateResult {
        internal string CommandText;
        internal LambdaExpression Projector;
    }

    private TranslateResult Translate(Expression expression) {
        ProjectionExpression projection = expression as ProjectionExpression;
        if (projection == null) {
            expression = Evaluator.PartialEval(expression);
            projection = (ProjectionExpression)new QueryBinder().Bind(expression);
        }
        string commandText = new QueryFormatter().Format(projection.Source);
        LambdaExpression projector = new ProjectionBuilder().Build(projection.Projector, projection.Source.Alias);
        return new TranslateResult { CommandText = commandText, Projector = projector };
    }
}

唯一有变化的是Translate方法。当传进来的参数是ProjectionExpression时，就不再进行将表达式转换成ProjectionExpression的操作，而是直接跳到构建SQL命令和投影器的步骤。

差点忘记，我还添加了类似LINQ to SQL的日志的特性，它能帮助我们看清背后的执行过程。我的上下文类里面也加了Log属性。

public class Northwind {
    public Query<Customers> Customers;
    public Query<Orders> Orders;

    private DbQueryProvider provider;
    public Northwind(DbConnection connection) {
        this.provider = new DbQueryProvider(connection);
        this.Customers = new Query<Customers>(this.provider);
        this.Orders = new Query<Orders>(this.provider);
    }

    public TextWriter Log {
        get { return this.provider.Log; }
        set { this.provider.Log = value; }
    }
}

Taking it for a Spin

现在，让我们试试这个新的魔法般的特性把。

string city = "London";
var query = from c in db.Customers
            where c.City == city
            select new {
                Name = c.ContactName,
                Orders = from o in db.Orders
                         where o.CustomerID == c.CustomerID
                         select o
            };


   foreach (var item in query) {
       Console.WriteLine("{0}", item.Name);
       foreach (var ord in item.Orders) {
           Console.WriteLine("\tOrder: {0}", ord.OrderID);
       }
   }

执行上面的代码，产生如下输出：

Thomas Hardy
        Order: 10355
        Order: 10383
        Order: 10453
        Order: 10558
        Order: 10707
        Order: 10741
        Order: 10743
        Order: 10768
        Order: 10793
        Order: 10864
        Order: 10920
        Order: 10953
        Order: 11016
Victoria Ashworth
        Order: 10289
        Order: 10471
        Order: 10484
        Order: 10538
        Order: 10539
        Order: 10578
        Order: 10599
        Order: 10943
        Order: 10947
        Order: 11023
Elizabeth Brown
        Order: 10435
        Order: 10462
        Order: 10848
Ann Devon
        Order: 10364
        Order: 10400
        Order: 10532
        Order: 10726
        Order: 10987
        Order: 11024
        Order: 11047
        Order: 11056
Simon Crowther
        Order: 10517
        Order: 10752
        Order: 11057
Hari Kumar
        Order: 10359
        Order: 10377
        Order: 10388
        Order: 10472
        Order: 10523
        Order: 10547
        Order: 10800
        Order: 10804
        Order: 10869

下面是查询的执行过程（我用了新的Log属性捕捉到的）：

SELECT t2.ContactName, t2.CustomerID
FROM (
  SELECT t1.CustomerID, t1.ContactName, t1.Phone, t1.City, t1.Country
  FROM (
    SELECT t0.CustomerID, t0.ContactName, t0.Phone, t0.City, t0.Country
    FROM Customers AS t0
  ) AS t1
  WHERE (t1.City = 'London')
) AS t2

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'AROUT')

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'BSBEV')

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'CONSH')

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'EASTC')

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'NORTS')

SELECT t4.OrderID, t4.CustomerID, t4.OrderDate
FROM (
  SELECT t3.OrderID, t3.CustomerID, t3.OrderDate
  FROM Orders AS t3
) AS t4
WHERE (t4.CustomerID = 'SEVES')

虽然让内层查询执行许多次不是很理想，但是总比直接抛出一个异常要好。

现在，Select操作已经最终完成了，它现在已经可以支持任意的投影了。也许吧:-)

Query6.zip