Rafy 領域實體框架設計 - 重構 ORM 中的 Sql 生成

前言

---

Rafy 領域實體框架作為一個使用領域驅動設計作為指導思想的開發框架，必然要處理領域實體到數據庫表之間的映射，即包含了 ORM 的功能。由於在 09 年最初設計時，ORM 部分的設計並不是最重要的部分，那里 Rafy 的核心是產品線工程、模型驅動開發、界面生成等。所以當時，我們簡單地采用了一個開源的小型 ORM 框架：《Lite ORM Library》。這個 ORM 框架可以生成比較簡單的 Sql 語句，以處理一般性的情況。

隨着不斷使用，我們也不斷對 ORM 的源碼做了不少改動，讓它在支持簡單語句生成的同時，也支持讓開發人員直接使用手動編寫的 Sql 語句來查詢領域實體。但是過程中，一直沒有修改最核心的 Sql 語句生成模塊。隨着應用的不斷深入，遇到的場景越來越多，需要生成復雜 Sql 語句的場景也越來越多。而這些場景如果還讓開發人員自己去編寫復雜 Sql 語句，不但框架的易用性下降，而且由於寫了過多的 Sql 語句，還會讓開發人員面向領域實體來開發的思想減弱。

這兩周，我們對 Sql 語句生成模塊實施了重構。與其說是重構，不如說重寫，因為 90% Lite ORM 的類庫都已經不再使用。但是又不得不面對對歷史代碼中接口的兼容性問題。接下來，將說明本次重構中的關鍵技術點。

 

舊代碼講解

---

最初采用的 Lite ORM 是一個輕量級的 ORM 框架，采用在實體對象上標記特性（Attribute）來聲明實體的元數據，並使用鏈式接口來作為查詢接口以方便開發人員使用。這是一個簡單、易移植的 ORM 框架，對初次使用、設計 ORM 的同學來說，可以起到一個很好的借鑒作用。相關的設計，可以參考 Lite ORM 的原文章：《Lite ORM Library V2 》。

由於這幾年我們已經對該框架做了大量的修改，所以很多接口已經與原框架不一致了。IQuery 作為描述查詢的核心類型，被重命名為 IPropertyQuery，所有方法的參數也都直接面向 Rafy 實體的《托管屬性》。但是在整體結構上，還是與原框架保持一致。例如，它還只是一個一維的結構：

/// <summary>
/// 使用托管屬性進行查詢的條件封裝。
/// </summary>
public interface IPropertyQuery : IDirectlyConstrain
{
    /// <summary>
    /// 是否還沒有任何語句
    /// </summary>
    bool IsEmpty { get; }

    /// <summary>
    /// 當前的查詢是一個分頁查詢，並使用這個對象來描述分頁的信息。
    /// </summary>
    PagingInfo PagingInfo { get; }

    /// <summary>
    /// 用於查詢的 Where 條件。
    /// </summary>
    IConstraintGroup Where { get; set; }

    /// <summary>
    /// 對引用屬性指定的表使用關聯查詢
    ///
    /// 調用此語句會生成相應的 INNER JOIN 語句，並把所有關聯的數據在 SELECT 中加上。
    ///
    /// 注意！！！
    /// 目前不支持同時 Join 兩個不同的引用屬性，它們都引用同一個實體/表。
    /// </summary>
    /// <param name="property"></param>
    /// <param name="type">是否同時查詢出相關的實體數據。</param>
    /// <param name="propertyOwner">
    /// 顯式指定該引用屬性對應的擁有類型。
    /// 一般使用在以下情況中：當引用屬性定義在基類中，而當前正在對子類進行查詢時。
    /// </param>
    /// <returns></returns>
    IPropertyQuery JoinRef(IRefProperty property, JoinRefType type = JoinRefType.JoinOnly, Type propertyOwner = null);

    /// <summary>
    /// 按照某個屬性排序。
    ///
    /// 可以調用此方法多次來指定排序的優先級。
    /// </summary>
    /// <param name="property">按照此屬性排序</param>
    /// <param name="direction">排序方向。</param>
    /// <returns></returns>
    IPropertyQuery OrderBy(IManagedProperty property, OrderDirection direction);

    //其它部分省略...
}

可以看到，該類型以一維的形式來描述了一個 Sql 查詢的相關元素：Join 數據源、Where 條件、OrderBy 規則、分頁信息。

只有其中的 Where 條件被設計為樹型結構來處理相對復雜的 And、Or 連接的條件。

可以看到，雖然有 SqlWhereConstraint 來添加任意的 Sql 語句作為 Where 約束條件，但是這樣的結構還是比較簡單，不足以描述所有的 Sql。

 

重構方案

---

我們的目標是實現復雜 Sql 的生成，理論上需要支持所有能想到的 Sql 語句的生成。

初期方案其實很簡單，就是使用解釋器模式與訪問器模式配合來重構底層代碼。根據 Sql 的語法規定，構造 Sql 語法樹節點中的相關類型，這樣就可以用一棵樹來解釋任意的 Sql 語句；同時使用訪問器模式來遍歷某個具體 Sql 語法樹。過程中還需要特別注意，盡量不要構造不必要的樹節點，以增加垃圾回收器的壓力。

在此初步方案上，還需要考慮：分層架構、組件間依賴、以及舊代碼的兼容性設計。

以下是整個方案的分層設計：

SqlTree：核心的、可重用的 Sql 語法樹層。定義了通用的 Sql 語法結構，並解決從語法樹到 Sql 語句的轉換、生成，以及屏蔽不同數據庫間不同子句的生成規則。

EntityQuery：把 SqlTree 作為類庫引用，同時整合領域實體、實體屬性的設計。

Query Interface：以 IQuery 接口的方式提供給應用層。

Linq Query：為了給開發人員提供更易用的接口，需要提供 Linq 語法的支持。本層用於解析 Linq 表達式樹，並生成最終的實體查詢的對象。

Property Query：為了兼容舊的接口，該部分在提供舊接口的前提下，換為使用新的 IQuery 來實現。

Application：開發人員的應用層代碼。可以使用最易用的 Linq、舊的 PropertyQuery，同時也可以直接使用 IQuery 接口來完成復雜查詢。

 

組件詳細設計

---

Sql 語法樹

 

使用解釋器模式設計，用於描述 Sql 查詢語句。

所有樹節點都從 SqlNode 繼承，並擁有自己的屬性來描述不同的節點位置。例如 SqlSelect 類型，代碼如下：

/// <summary>
/// 表示一個 Sql 查詢語句。
/// </summary>
class SqlSelect : SqlNode
{
    private IList _orderBy;

    public override SqlNodeType NodeType
    {
        get { return SqlNodeType.SqlSelect; }
    }

    /// <summary>
    /// 是否只查詢數據的條數。
    ///
    /// 如果這個屬性為真，那么不再需要使用 Selection。
    /// </summary>
    public bool IsCounting { get; set; }

    /// <summary>
    /// 是否需要查詢不同的結果。
    /// </summary>
    public bool IsDistinct { get; set; }

    /// <summary>
    /// 如果指定此屬性，表示需要查詢的條數。
    /// </summary>
    public int? Top { get; set; }

    /// <summary>
    /// 要查詢的內容。
    /// 如果本屬性為空，表示要查詢所有列。
    /// </summary>
    public SqlNode Selection { get; set; }

    /// <summary>
    /// 要查詢的數據源。
    /// </summary>
    public SqlSource From { get; set; }

    /// <summary>
    /// 查詢的過濾條件。
    /// </summary>
    public SqlConstraint Where { get; set; }

    /// <summary>
    /// 查詢的排序規則。
    /// 可以指定多個排序條件，其中每一項都必須是一個 SqlOrderBy 對象。
    /// </summary>
    public IList OrderBy
    {
        get
        {
            if (_orderBy == null)
            {
                _orderBy = new ArrayList();
            }
            return _orderBy;
        }
        internal set { _orderBy = value; }
    }

    //...
}

 

Sql 生成器

 

使用訪問器模式設計，用於遍歷整個 Sql 語法樹。以下是 SqlNodeVisitor 的代碼：

/// <summary>
/// SqlNode 語法樹的訪問器
/// </summary>
abstract class SqlNodeVisitor
{
    protected SqlNode Visit(SqlNode node)
    {
        switch (node.NodeType)
        {
            case SqlNodeType.SqlLiteral:
                return this.VisitSqlLiteral(node as SqlLiteral);
            case SqlNodeType.SqlSelect:
                return this.VisitSqlSelect(node as SqlSelect);
            case SqlNodeType.SqlColumn:
                return this.VisitSqlColumn(node as SqlColumn);
            case SqlNodeType.SqlTable:
                return this.VisitSqlTable(node as SqlTable);
            case SqlNodeType.SqlColumnConstraint:
                return this.VisitSqlColumnConstraint(node as SqlColumnConstraint);
            case SqlNodeType.SqlBinaryConstraint:
                return this.VisitSqlBinaryConstraint(node as SqlBinaryConstraint);
            case SqlNodeType.SqlJoin:
                return this.VisitSqlJoin(node as SqlJoin);
            case SqlNodeType.SqlArray:
                return this.VisitSqlArray(node as SqlArray);
            case SqlNodeType.SqlSelectAll:
                return this.VisitSqlSelectAll(node as SqlSelectAll);
            case SqlNodeType.SqlColumnsComparisonConstraint:
                return this.VisitSqlColumnsComparisonConstraint(node as SqlColumnsComparisonConstraint);
            case SqlNodeType.SqlExistsConstraint:
                return this.VisitSqlExistsConstraint(node as SqlExistsConstraint);
            case SqlNodeType.SqlNotConstraint:
                return this.VisitSqlNotConstraint(node as SqlNotConstraint);
            case SqlNodeType.SqlSubSelect:
                return this.VisitSqlSubSelect(node as SqlSubSelect);
            default:
                break;
        }
        throw new NotImplementedException();
    }

    protected virtual SqlJoin VisitSqlJoin(SqlJoin sqlJoin)
    {
        this.Visit(sqlJoin.Left);
        this.Visit(sqlJoin.Right);
        this.Visit(sqlJoin.Condition);
        return sqlJoin;
    }

    protected virtual SqlBinaryConstraint VisitSqlBinaryConstraint(SqlBinaryConstraint node)
    {
        this.Visit(node.Left);
        this.Visit(node.Right);
        return node;
    }

    //...
}

 

基於實體的查詢

1. IQuery 相關接口用於描述整個基於實體的查詢。

例如，IColumnNode 表示一個列節點，其實是由一個實體屬性來指定的：

namespace Rafy.Domain.ORM.Query
{
    /// <summary>
    /// 一個列節點
    /// </summary>
    public interface IColumnNode : IQueryNode
    {
        /// <summary>
        /// 本列屬於指定的數據源
        /// </summary>
        INamedSource Owner { get; set; }

        /// <summary>
        /// 本屬性對應一個實體的托管屬性
        /// </summary>
        IManagedProperty Property { get; set; }

        /// <summary>
        /// 本屬性在查詢結果中使用的別名。
        /// </summary>
        string Alias { get; set; }
    }
}

 

2. EntityQuery 層中的類型實現了 IQuery 中對應的接口，並使用領域實體的相關 API 來實現從實體到表、實體屬性到列的轉換。同時，為了減少對象的數量，這些類型與 Sql 語法樹的關系都使用繼承，而不是關聯。也就是說，它們直接從 SqlTree 對應的類型上繼承下來，這樣，在構造 EntityQuery 的同時，也構造好了底層的 Sql 語法樹。

3. QueryFactory 封裝了大量易用的 API 來構造 IQuery 接口。

 

使用示例

---

下面，就以幾個典型的單元測試的相關代碼來說明新的查詢框架的使用方法：

使用 Linq 的數據層查詢

public int LinqCountByBookName(string name)
{
    return this.FetchCount(r => r.DA_LinqCountByBookName(name));
}
private EntityList DA_LinqCountByBookName(string name)
{
    var q = this.CreateLinqQuery();
    q = q.Where(c => c.Book.Name == name);
    return this.QueryList(q);
}

 

使用 IQuery 的數據層查詢

public int CountByBookName2(string name)
{
    return this.FetchCount(r => r.DA_CountByBookName2(name));
}
private EntityList DA_CountByBookName2(string name)
{
    var source = f.Table(this);
    var bookSource = f.Table<BookRepository>();
    var q = f.Query(
        from: f.Join(source, bookSource)
    );
    q.AddConstraintIf(Book.NameProperty, PropertyOperator.Equal, name);
    return this.QueryList(q);
}

可以看到，使用 IQuery 接口來查詢，雖然靈活性最大、性能更好，但是相對於 Linq 來說會更加復雜。

 

使用 IQuery 來生成 Sql

[TestMethod]
public void ORM_TableQuery_InSubSelect()
{
    var f = QueryFactory.Instance;
    var articleSource = f.Table(RF.Concrete<ArticleRepository>());
    var userSource = f.Table(RF.Concrete<BlogUserRepository>());
    var query = f.Query(
        from: userSource,
        where: f.Constraint(
            column: userSource.Column(BlogUser.IdProperty),
            op: PropertyOperator.In,
            value: f.Query(
                selection: articleSource.Column(Article.UserIdProperty),
                from: articleSource,
                where: f.Constraint(articleSource.Column(Article.CreateDateProperty), DateTime.Today)
            )
        )
    );

    var generator = new SqlServerSqlGenerator { AutoQuota = false };
    f.Generate(generator, query);
    var sql = generator.Sql;

    Assert.IsTrue(sql.ToString() ==
@"SELECT *
FROM BlogUser
WHERE BlogUser.Id IN (
SELECT Article.UserId
FROM Article
WHERE Article.CreateDate = {0}
)");
    Assert.IsTrue(sql.Parameters.Count == 1);
    Assert.IsTrue(sql.Parameters[0].Equals(DateTime.Today));
}

 

使用 SqlTree 來生成 Sql

[TestMethod]
public void ORM_SqlTree_Select_InSubSelect()
{
    var select = new SqlSelect();
    var articleTable = new SqlTable { TableName = "Article" };
    var subSelect = new SqlSelect
    {
        Selection = new SqlColumn { Table = articleTable, ColumnName = "UserId" },
        From = articleTable,
        Where = new SqlColumnConstraint
        {
            Column = new SqlColumn { Table = articleTable, ColumnName = "CreateDate" },
            Operator = SqlColumnConstraintOperator.Equal,
            Value = DateTime.Today
        }
    };

    var userTable = new SqlTable { TableName = "User" };
    select.Selection = new SqlSelectAll();
    select.From = userTable;
    select.Where = new SqlColumnConstraint
    {
        Column = new SqlColumn { Table = userTable, ColumnName = "Id" },
        Operator = SqlColumnConstraintOperator.In,
        Value = subSelect
    };

    var generator = new SqlServerSqlGenerator { AutoQuota = false };
    generator.Generate(select);
    var sql = generator.Sql;
    Assert.IsTrue(sql.ToString() == @"SELECT *
FROM User
WHERE User.Id IN (
SELECT Article.UserId
FROM Article
WHERE Article.CreateDate = {0}
)");
    Assert.IsTrue(sql.Parameters.Count == 1);
    Assert.IsTrue(sql.Parameters[0].Equals(DateTime.Today));
}

 

框架下載

---

框架使用測試驅動的方法開發，在開發時是先編寫相關的測試用例，再實現內部代碼。重構的同時，我們為能想到的場景都編寫了測試用例：

 

目前，框架版本也升級到了 2.23.2155。

有興趣的同學，了解、下載最新的框架，請參考：《Rafy 領域實體框架發布！》。（框架目前不開源，但可免費使用。）