詳解如何在C#類型系統(tǒng)上實(shí)現(xiàn)一個(gè)SQL查詢引擎TypedSql

更新時(shí)間：2025年11月24日 08:27:22 作者：hez2010

這篇文章主要為大家詳細(xì)介紹了如何在C#類型系統(tǒng)上實(shí)現(xiàn)一個(gè)SQL查詢引擎TypedSql,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

前言

在 .NET 里寫查詢的時(shí)候，很多場景下數(shù)據(jù)其實(shí)早就都在內(nèi)存里了：不是數(shù)據(jù)庫連接，也不是某個(gè)遠(yuǎn)程服務(wù)的結(jié)果，而就是一個(gè)數(shù)組或者 List<T>。我只是想過濾一下、投影一下。這時(shí)候，通常有幾種選擇：

寫一個(gè) foreach 循環(huán) —— 性能好、可控，但代碼稍微有點(diǎn)啰嗦；
用 LINQ —— 寫起來舒服，看起來也優(yōu)雅，就是有迭代器、委托帶來的那點(diǎn)開銷；
要么干脆極端一點(diǎn)：把數(shù)據(jù)塞進(jìn)數(shù)據(jù)庫，再寫真正的 SQL（這聽起來就有點(diǎn)反直覺……）

但是我想嘗試一條完全不同的思路：如果我們把 C# 的類型系統(tǒng)本身，當(dāng)成查詢計(jì)劃會(huì)怎樣？

也就是說，不是像平時(shí)那樣：

在運(yùn)行時(shí)構(gòu)建一棵表達(dá)式樹，
再拿著這棵樹去解釋執(zhí)行整個(gè)查詢；

而是：寫一段 SQL 風(fēng)格的字符串，把它編譯成一個(gè)類型，這個(gè)類型從頭到尾描述了整個(gè)查詢管道，然后所有實(shí)際運(yùn)行時(shí)的邏輯都走靜態(tài)方法。

這個(gè)想法最終促成了 TypedSql —— 一個(gè)用 C# 類型系統(tǒng)實(shí)現(xiàn)的內(nèi)存內(nèi) SQL 查詢引擎。

把查詢變成嵌套的泛型類型

TypedSql 的核心想法看上去非常簡單：一個(gè)查詢，其實(shí)可以是一串嵌套的泛型類型，比如 WhereSelect<TRow, …, Stop<...>> 這樣。

順著這個(gè)想法，再往下推幾步，會(huì)自然落到一套具體的設(shè)計(jì)上。

把執(zhí)行計(jì)劃塞進(jìn)類型系統(tǒng)

在 TypedSql 里，每一個(gè)編譯好的查詢，最終都會(huì)變成一個(gè)封閉的泛型管道類型。
這個(gè)管道是由一些基礎(chǔ)節(jié)點(diǎn)拼出來的，比如：

Where<TRow, TPredicate, TNext, TResult, TRoot>
Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>
WhereSelect<TRow, TPredicate, TProjection, TNext, TMiddle, TResult, TRoot>
Stop<TResult, TRoot>

每個(gè)節(jié)點(diǎn)都實(shí)現(xiàn)了同一個(gè)接口：

internal interface IQueryNode<TRow, TResult, TRoot>
{
    static abstract void Run(ReadOnlySpan<TRow> rows, scoped ref QueryRuntime<TResult> runtime);

    static abstract void Process(in TRow row, scoped ref QueryRuntime<TResult> runtime);
}

這里可以簡單理解成：

Run 是外面那一圈大循環(huán)（整體遍歷）；
Process 是對單行執(zhí)行的邏輯。

比如 Where 節(jié)點(diǎn)大概長這樣：

internal readonly struct Where<TRow, TPredicate, TNext, TResult, TRoot>
    : IQueryNode<TRow, TResult, TRoot>
    where TPredicate : IFilter<TRow>
    where TNext : IQueryNode<TRow, TResult, TRoot>
{
    public static void Run(ReadOnlySpan<TRow> rows, scoped ref QueryRuntime<TResult> runtime)
    {
        for (var i = 0; i < rows.Length; i++)
        {
            Process(in rows[i], ref runtime);
        }
    }

    public static void Process(in TRow row, scoped ref QueryRuntime<TResult> runtime)
    {
        if (TPredicate.Evaluate(in row))
        {
            TNext.Process(in row, ref runtime);
        }
    }
}

關(guān)鍵點(diǎn)在于：

管道的形狀，完全藏在這些類型參數(shù)里面；
每個(gè)節(jié)點(diǎn)是一個(gè)只有靜態(tài)方法的 struct —— 不需要?jiǎng)?chuàng)建實(shí)例，沒有虛調(diào)用。

對 JIT 來說，一旦這些泛型類型參數(shù)都被代入，這就是一張普通的靜態(tài)調(diào)用圖而已。

列和投影

查詢總得運(yùn)行在某種行類型 TRow 上，這通常是你自己定義的一個(gè) record/class/struct。

每一列會(huì)實(shí)現(xiàn)這樣一個(gè)接口：

internal interface IColumn<TRow, TValue>
{
    static abstract string Identifier { get; }

    static abstract TValue Get(in TRow row);
}

舉個(gè)簡單的例子：

internal readonly struct PersonNameColumn : IColumn<Person, string>
{
    public static string Identifier => "Name";

    public static string Get(in Person row) => row.Name;
}

而投影（SELECT 后面那部分）則實(shí)現(xiàn)：

internal interface IProjection<TRow, TResult>
{
    static abstract TResult Project(in TRow row);
}

將選出某一列本身做成一個(gè)投影，可以這么寫：

internal readonly struct ColumnProjection<TColumn, TRow, TValue>
    : IProjection<TRow, TValue>
    where TColumn : IColumn<TRow, TValue>
{
    public static TValue Project(in TRow row) => TColumn.Get(row);
}

多列選擇時(shí)，TypedSql 會(huì)構(gòu)造專門的投影，把結(jié)果拼成 ValueTuple：

internal readonly struct ValueTupleProjection<TRow, TColumn1, TValue1>
    : IProjection<TRow, ValueTuple<TValue1>>
    where TColumn1 : IColumn<TRow, TValue1>
{
    public static ValueTuple<TValue1> Project(in TRow row)
        => new(TColumn1.Get(row));
}

// … 一直到 7 列，然后通過一個(gè)“Rest”再遞歸掛一個(gè) IProjection

還是同樣的模式：全是 struct，全是靜態(tài)方法。

過濾器

過濾器的接口長這樣：

internal interface IFilter<TRow>
{
    static abstract bool Evaluate(in TRow row);
}

一個(gè)最常用的比較過濾器形式，是列 + 字面量：

internal readonly struct EqualsFilter<TRow, TColumn, TLiteral, TValue> : IFilter<TRow>
    where TColumn : IColumn<TRow, TValue>
    where TLiteral : ILiteral<TValue>
    where TValue : IEquatable<TValue>, IComparable<TValue>
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool Evaluate(in TRow row)
    {
        if (typeof(TValue).IsValueType)
        {
            return TColumn.Get(row).Equals(TLiteral.Value);
        }
        else
        {
            var left = TColumn.Get(row);
            var right = TLiteral.Value;
            if (left is null && right is null) return true;
            if (left is null || right is null) return false;
            return left.Equals(right);
        }
    }
}

這里我們通過判斷 TValue 是值類型還是引用類型，來分別處理 null 的情況。.NET 的 JIT 能夠識(shí)別這種模式，并且為值類型和引用類型分別特化并生成不同的代碼路徑，從而實(shí)際上并不存在任何的分支開銷。

GreaterThanFilter、LessThanFilter、GreaterOrEqualFilter、LessOrEqualFilter、NotEqualFilter 等等，都是同樣的套路。

邏輯運(yùn)算也是在類型層面組合的：

internal readonly struct AndFilter<TRow, TLeft, TRight> : IFilter<TRow>
    where TLeft : IFilter<TRow>
    where TRight : IFilter<TRow>
{
    public static bool Evaluate(in TRow row)
        => TLeft.Evaluate(in row) && TRight.Evaluate(in row);
}

internal readonly struct OrFilter<TRow, TLeft, TRight> : IFilter<TRow>
    where TLeft : IFilter<TRow>
    where TRight : IFilter<TRow>
{
    public static bool Evaluate(in TRow row)
        => TLeft.Evaluate(in row) || TRight.Evaluate(in row);
}

internal readonly struct NotFilter<TRow, TPredicate> : IFilter<TRow>
    where TPredicate : IFilter<TRow>
{
    public static bool Evaluate(in TRow row)
        => !TPredicate.Evaluate(in row);
}

所以，一條 WHERE 子句，最終就會(huì)變成一棵泛型過濾器類型樹，每個(gè)節(jié)點(diǎn)只有一個(gè)靜態(tài) Evaluate 方法。

值類型特化版字符串：ValueString

在 .NET 里，string 是一個(gè)引用類型，這給 TypedSql 帶來了一些麻煩：.NET 會(huì)對引用類型采用共享泛型在運(yùn)行時(shí)做分發(fā)，而不是為 string 泛型實(shí)例化一個(gè)具體類型，這使得運(yùn)行時(shí)會(huì)產(chǎn)生類型字典查找的開銷。雖然這點(diǎn)開銷不大，但是 TypedSql 追求的是媲美手寫循環(huán)的性能，所以我想盡量把熱路徑里涉及的類型都做成值類型。

于是我選擇把字符串包在一個(gè)小的值類型里：

internal readonly struct ValueString(string? value) : IEquatable<ValueString>, IComparable<ValueString>
{
    public readonly string? Value = value;

    public int CompareTo(ValueString other)
        => string.Compare(Value, other.Value, StringComparison.Ordinal);

    public bool Equals(ValueString other)
    {
        return string.Equals(Value, other.Value, StringComparison.Ordinal);
    }

    public override string? ToString() => Value;

    public static implicit operator ValueString(string value) => new(value);

    public static implicit operator string?(ValueString value) => value.Value;
}

再配一個(gè)適配器，把原來的 string 列變成 ValueString 列：

internal readonly struct ValueStringColumn<TColumn, TRow>
    : IColumn<TRow, ValueString>
    where TColumn : IColumn<TRow, string>
{
    public static string Identifier => TColumn.Identifier;

    public static ValueString Get(in TRow row)
        => new(TColumn.Get(in row));
}

在內(nèi)部，所有字符串列都統(tǒng)一成 ValueString，有幾個(gè)好處：

熱路徑里盡量是值類型，少一點(diǎn)引用類型的干擾；
避開了泛型共享帶來的類型字典查找開銷。

對使用者來說，你照樣寫 string，而我的 TypedSql 會(huì)在內(nèi)部自動(dòng)在邊緣位置做封裝/解封裝，所以完全透明。

實(shí)現(xiàn)一個(gè) SQL 子集

TypedSql 并不打算做成一個(gè)大而全的 SQL 引擎，而是針對單表、內(nèi)存內(nèi)查詢，設(shè)計(jì)了一個(gè)很小的 SQL 方言：

支持這些語句：

SELECT * FROM $
SELECT col FROM $
SELECT col1, col2, ... FROM $
WHERE 支持：
- 比較：=, !=, >, <, >=, <=
- 布爾：AND, OR, NOT
- 括號
字面量支持：
- 整數(shù)（如 42）
- 浮點(diǎn)數(shù)（如 123.45）
- 布爾（true / false）
- 單引號字符串（'Seattle'，內(nèi)部用 '' 轉(zhuǎn)義）
- null
列名大小寫不敏感
$ 代表當(dāng)前行來源

整體解析流程很簡單：

先把 SQL 字符串切成 token；
再構(gòu)建一棵小 AST，包含：
- ParsedQuery：整體查詢
- Selection：SelectAll 或者列名列表
- WhereExpression：篩選表達(dá)式
  - ComparisonExpression：比較
  - AndExpression：與
  - OrExpression：或
  - NotExpression：非
- LiteralValue：字面量
  - LiteralKind.Integer + IntValue
  - LiteralKind.Float + FloatValue
  - LiteralKind.Boolean + BoolValue
  - LiteralKind.String + StringValue（string?）
  - LiteralKind.Null

在這個(gè)階段，整個(gè)系統(tǒng)其實(shí)完全不知道 C# 里面的類型是什么樣的，列又是什么，只是單純看作 SQL 結(jié)構(gòu)。

類型檢查、以及這個(gè)字面量能不能用在那一列上之類的問題，會(huì)留到后面的編譯階段去做。

把字面量變成類型 —— 包括字符串

在這里，我想針對每一個(gè) SQL 語句都生成一份獨(dú)特的類型，因此作為查詢條件中的字面量，也必須變成類型參數(shù)的一部分。

于是，在 TypeSql 中，所有的字面量類型都實(shí)現(xiàn)同一個(gè)接口：

internal interface ILiteral<T>
{
    static abstract T Value { get; }
}

適用范圍包括：

整數(shù)（int）
浮點(diǎn)數(shù)（float）
字符（char）
布爾（bool）
字符串（這里是 ValueString，內(nèi)部包 string?）
……未來還可以擴(kuò)展更多

數(shù)值字面量

數(shù)值字面量的編碼方式很直接：用 16 進(jìn)制和位運(yùn)算拼出來。

先來一組 IHex 接口和 Hex0–HexF struct：

internal interface IHex { static abstract int Value { get; } }

internal readonly struct Hex0 : IHex { public static int Value => 0; }
// ...
internal readonly struct HexF : IHex { public static int Value => 15; }

然后，一個(gè)整型字面量長這樣：

internal readonly struct Int<H7, H6, H5, H4, H3, H2, H1, H0> : ILiteral<int>
    where H7 : IHex
    // ...
    where H0 : IHex
{
    public static int Value
        => (H7.Value << 28)
         | (H6.Value << 24)
         | (H5.Value << 20)
         | (H4.Value << 16)
         | (H3.Value << 12)
         | (H2.Value <<  8)
         | (H1.Value <<  4)
         |  H0.Value;
}

浮點(diǎn)數(shù)也是一樣的 8 個(gè)十六進(jìn)制數(shù)位，只不過最后用 Unsafe.BitCast<int, float> 轉(zhuǎn)回 float：

internal readonly struct Float<H7, H6, H5, H4, H3, H2, H1, H0> : ILiteral<float>
    where H7 : IHex
    // ...
{
    public static float Value
        => Unsafe.BitCast<int, float>(
               (H7.Value << 28)
             | (H6.Value << 24)
             | (H5.Value << 20)
             | (H4.Value << 16)
             | (H3.Value << 12)
             | (H2.Value <<  8)
             | (H1.Value <<  4)
             |  H0.Value);
}

字符則是 4 個(gè)十六進(jìn)制數(shù)位：

internal readonly struct Char<H3, H2, H1, H0> : ILiteral<char>
    where H3 : IHex
    // ...
{
    public static char Value
        => (char)((H3.Value << 12)
                | (H2.Value <<  8)
                | (H1.Value <<  4)
                |  H0.Value);
}

字符串字面量：類型的鏈表

字符串字面量就比較有趣了。

這里我選擇在類型層面構(gòu)建一條字符鏈表，用接口 IStringNode 來描述：

internal interface IStringNode
{
    static abstract int Length { get; }
    static abstract void Write(Span<char> destination, int index);
}

有三個(gè)實(shí)現(xiàn)：

StringEnd：字符串的結(jié)尾（長度 0）；
StringNull：表示 null 字符串（長度 -1）；
StringNode<TChar, TNext>：當(dāng)前一個(gè)字符 + 剩余部分。

internal readonly struct StringEnd : IStringNode
{
    public static int Length => 0;
    public static void Write(Span<char> destination, int index) { }
}

internal readonly struct StringNull : IStringNode
{
    public static int Length => -1;
    public static void Write(Span<char> destination, int index) { }
}

internal readonly struct StringNode<TChar, TNext> : IStringNode
    where TChar : ILiteral<char>
    where TNext : IStringNode
{
    public static int Length => 1 + TNext.Length;

    public static void Write(Span<char> destination, int index)
    {
        destination[index] = TChar.Value;
        TNext.Write(destination, index + 1);
    }
}

有了這樣的類型鏈表，我們就可以基于某個(gè) IStringNode，構(gòu)造出真正的 ValueString：

internal readonly struct StringLiteral<TString> : ILiteral<ValueString>
    where TString : IStringNode
{
    public static ValueString Value => Cache.Value;

    private static class Cache
    {
        public static readonly ValueString Value = Build();

        private static ValueString Build()
        {
            var length = TString.Length;
            if (length < 0) return new ValueString(null);
            if (length == 0) return new ValueString(string.Empty);

            var chars = new char[length];
            TString.Write(chars.AsSpan(), 0);
            return new string(chars, 0, length);
        }
    }
}

StringLiteral<TString> 就是一個(gè) ILiteral<ValueString>，它的 Value 在類型初始化時(shí)算好并緩存下來，所以只需要計(jì)算一次，后續(xù)訪問都是直接讀靜態(tài)字段，非常高效。

把字符串塞進(jìn)類型

LiteralTypeFactory.CreateStringLiteral 負(fù)責(zé)把字符串字面量轉(zhuǎn)換成這樣一個(gè)類型：

public static Type CreateStringLiteral(string? value)
{
    if (value is null)
    {
        return typeof(StringLiteral<StringNull>);
    }

    var type = typeof(StringEnd);
    for (var i = value.Length - 1; i >= 0; i--)
    {
        var charType = CreateCharType(value[i]); // Char<...>
        type = typeof(StringNode<,>).MakeGenericType(charType, type);
    }

    return typeof(StringLiteral<>).MakeGenericType(type);
}

比如我們有一個(gè)字面量 'Seattle'，整個(gè)流程大致是：

解析階段讀到 'Seattle'，生成一個(gè) LiteralValue：

Kind == LiteralKind.String
StringValue == "Seattle"

編譯階段根據(jù)列的類型判斷：這是個(gè)字符串列，于是對應(yīng)的運(yùn)行時(shí)類型是 ValueString。

調(diào)用 CreateStringLiteral("Seattle")：

初始 type = typeof(StringEnd)；

從右到左遍歷每個(gè)字符：

'e' → 得到一個(gè) Char<…> 類型（4 個(gè)十六進(jìn)制數(shù)位對應(yīng) Unicode）type = StringNode<Char<'e'>, StringEnd>
'l' 再往前：type = StringNode<Char<'l'>, StringNode<Char<'e'>, StringEnd>>
一直重復(fù)：'t'、't'、'a'、'e'、'S'……

最終得到類似這樣一個(gè)類型：

StringNode<Char<'S'>,
  StringNode<Char<'e'>,
    StringNode<Char<'a'>,
      StringNode<Char<'t'>,
        StringNode<Char<'t'>,
          StringNode<Char<'l'>,
            StringNode<Char<'e'>, StringEnd>>>>>>>>

最后再用 StringLiteral<> 把它包起來：

StringLiteral<
  StringNode<Char<'S'>,
    StringNode<Char<'e'>,
      ...
    >
  >
>

這一整個(gè)封閉泛型類型，就是字面量 'Seattle' 的類型版本。

而過濾器在需要值的時(shí)候，只是簡單地訪問 TLiteral.Value，再通過 TString.Length 和 TString.Write 復(fù)原出一個(gè) ValueString("Seattle")，其中復(fù)原通過靜態(tài)類型的緩存完成，借助類型系統(tǒng)的力量，每一個(gè)獨(dú)立的字面量都會(huì)產(chǎn)生一個(gè)單獨(dú)的類型實(shí)例，我們的字面量就緩存在那個(gè)類型的靜態(tài)字段里，從而避免了一切運(yùn)行時(shí)的計(jì)算開銷。

null 字符串字面量

null 的處理稍微特殊一點(diǎn)：

寫類似 WHERE Team != null 這種代碼時(shí)，解析器會(huì)把它識(shí)別為 LiteralKind.Null；
對字符串列來說，CreateStringLiteral(null) 會(huì)返回 typeof(StringLiteral<StringNull>)；
StringNull.Length == -1，于是 StringLiteral<StringNull>.Value 直接返回 new ValueString(null)。

這樣一來，null 和 "" 在類型層面和運(yùn)行時(shí)都可以被區(qū)分開。

字面量工廠

上面這些編碼最后都?xì)w到一個(gè)工廠類里統(tǒng)一封裝：

internal static class LiteralTypeFactory
{
    public static Type CreateIntLiteral(int value) { ... }
    public static Type CreateFloatLiteral(float value) { ... }
    public static Type CreateBoolLiteral(bool value) { ... }
    public static Type CreateStringLiteral(string? value) { ... }
}

SQL 編譯階段會(huì)根據(jù)兩方面信息來調(diào)用它：

列的運(yùn)行時(shí)類型（int、float、bool、ValueString）；
字面量的種類（Integer、Float、Boolean、String、Null）。

最終的效果就是：WHERE 子句里每一個(gè)字面量，都會(huì)變成一個(gè)具體的 ILiteral<T> 類型，值直接嵌在類型參數(shù)里。

搭好整個(gè)管道類型

到目前為止，我們已經(jīng)有了：

一棵解析出來的查詢（SELECT + WHERE）；
一份 schema，把列名映射到具體的 IColumn<TRow, TValue> 實(shí)現(xiàn)；
一套機(jī)制，把字面量變成 ILiteral<T> 類型。

SQL 編譯器接下來要做的就是，把這些東西變成：

一個(gè)封閉的管道類型 TPipeline，它實(shí)現(xiàn) IQueryNode<TRow, TRuntimeResult, TRoot>；
一個(gè)運(yùn)行時(shí)結(jié)果類型 TRuntimeResult；
一個(gè)對外公開的結(jié)果類型 TPublicResult。

編譯SELECT

先看選擇部分。

SELECT *

最簡單的情況就是：SELECT * FROM $。

這時(shí)候：

運(yùn)行時(shí)結(jié)果類型 = 行類型本身：TRuntimeResult = TRow；
公共結(jié)果類型也是 TRow；
管道尾部就是一個(gè) Stop<TRow, TRow> 節(jié)點(diǎn)。

大致邏輯如下：

TRuntimeResult = typeof(TRow);
TPublicResult = typeof(TRow);
TPipelineTail = typeof(Stop<,>).MakeGenericType(TRuntimeResult, typeof(TRow));

SELECT col/SELECT col1, col2, ...

當(dāng)有明確列投影時(shí)，步驟稍微多一點(diǎn)：

SELECT col：

根據(jù)列名解析出對應(yīng)的 ColumnMetadata；
決定它的運(yùn)行時(shí)值類型：
- 如果列類型本身不是 string，運(yùn)行時(shí)類型就跟它一致；
- 如果是 string，運(yùn)行時(shí)類型改為 ValueString；
構(gòu)建一個(gè) ColumnProjection<TRuntimeColumn, TRow, TRuntimeValue>。

SELECT col1, col2, ...：

分別解析每一列；
構(gòu)造一個(gè) ValueTupleProjection，返回一個(gè) ValueTuple<...>，里面放運(yùn)行時(shí)類型；
同時(shí)記錄一份公共 ValueTuple<...> 類型，用聲明的 CLR 類型（如 string）。

最后，無論是一列還是多列，都會(huì)在 Stop 前面再加一個(gè) Select 節(jié)點(diǎn)：

Select<TRow, TProjection, Stop<...>, TMiddle, TRuntimeResult, TRoot> → Stop<...>

這個(gè)節(jié)點(diǎn)內(nèi)部會(huì)調(diào)用投影的靜態(tài) Project 方法，再把結(jié)果轉(zhuǎn)交給 Stop.Process 處理。

編譯WHERE

WHERE 子句以遞歸方式編譯成類型。

布爾結(jié)構(gòu)

給定一個(gè)解析后的 WhereExpression 樹：

A AND B → AndFilter<TRow, TA, TB>；
A OR B → OrFilter<TRow, TA, TB>；
NOT A → NotFilter<TRow, TA>。

編譯器做的事情，大概是對這棵樹一層層往下調(diào)自己的方法：

Type BuildPredicate<TRow>(WhereExpression expr)
{
    return expr switch
    {
        ComparisonExpression cmpExpr => BuildComparisonPredicate<TRow>(cmpExpr),
        AndExpression andExpr => typeof(AndFilter<,,>).MakeGenericType(typeof(TRow), BuildPredicate<TRow>(andExpr.Left), BuildPredicate<TRow>(andExpr.Right)),
        OrExpression orExpr => typeof(OrFilter<,,>).MakeGenericType(typeof(TRow), BuildPredicate<TRow>(orExpr.Left), BuildPredicate<TRow>(orExpr.Right)),
        NotExpression notExpr => typeof(NotFilter<,>).MakeGenericType(typeof(TRow), BuildPredicate<TRow>(notExpr.Expression)),
        _ => throw …
    };
}

比較表達(dá)式

每一個(gè)葉子比較表達(dá)式，比如：

City = 'Seattle'
Salary >= 180000
Team != null

都會(huì)變成一個(gè)具體的過濾器類型：

Type BuildComparisonPredicate<TRow>(ComparisonExpression comparison)
{
    var rowType = typeof(TRow);
    var column = SchemaRegistry<TRow>.ResolveColumn(comparison.ColumnIdentifier);

    var runtimeColumnType      = column.GetRuntimeColumnType(rowType);
    var runtimeColumnValueType = column.GetRuntimeValueType();

    var literalType = CreateLiteralType(runtimeColumnValueType, comparison.Literal);

    var filterDefinition = comparison.Operator switch
    {
        ComparisonOperator.Equals        => typeof(EqualsFilter<,,,>),
        ComparisonOperator.GreaterThan   => typeof(GreaterThanFilter<,,,>),
        ComparisonOperator.LessThan      => typeof(LessThanFilter<,,,>),
        ComparisonOperator.GreaterOrEqual=> typeof(GreaterOrEqualFilter<,,,>),
        ComparisonOperator.LessOrEqual   => typeof(LessOrEqualFilter<,,,>),
        ComparisonOperator.NotEqual      => typeof(NotEqualFilter<,,,>),
        _ => throw …
    };

    return filterDefinition.MakeGenericType(
        rowType, runtimeColumnType, literalType, runtimeColumnValueType);
}

以 City = 'Seattle' 為例，如果那一列是字符串列，那么：

運(yùn)行時(shí)列類型是：ValueStringColumn<PersonCityColumn, Person>；
運(yùn)行時(shí)值類型是：ValueString；
字面量類型，則是通過 CreateStringLiteral("Seattle") 得到的某個(gè) StringLiteral<SomeStringNode<…>>。

最后組合出一個(gè)過濾器類型：

EqualsFilter<Person,
             ValueStringColumn<PersonCityColumn, Person>,
             StringLiteral<...>,
             ValueString>

到這一步，我們就可以把一個(gè) Where 節(jié)點(diǎn)掛到管道上了：

Where<TRow, TPredicate, TNext, TRuntimeResult, TRoot> → ...

把Where和Select融合起來

直接這么拼出來的管道是正確的，但在性能上還能再優(yōu)化一點(diǎn)：
Where 和 Select 其實(shí)可以合并成一步。

TypedSql 里有一個(gè)很小的優(yōu)化器，會(huì)去找這樣的模式：

Where<TRow, TPredicate, Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>, TResult, TRoot>

一旦發(fā)現(xiàn)，就把它替換成：

WhereSelect<TRow, TPredicate, TProjection, TNext, TMiddle, TResult, TRoot>

這個(gè)融合節(jié)點(diǎn)的實(shí)現(xiàn)如下：

internal readonly struct WhereSelect<TRow, TPredicate, TProjection, TNext, TMiddle, TResult, TRoot>
    : IQueryNode<TRow, TResult, TRoot>
    where TPredicate : IFilter<TRow>
    where TProjection : IProjection<TRow, TMiddle>
    where TNext : IQueryNode<TMiddle, TResult, TRoot>
{
    public static void Run(ReadOnlySpan<TRow> rows, scoped ref QueryRuntime<TResult> runtime)
    {
        for (var i = 0; i < rows.Length; i++)
        {
            Process(in rows[i], ref runtime);
        }
    }

    public static void Process(in TRow row, scoped ref QueryRuntime<TResult> runtime)
    {
        if (TPredicate.Evaluate(in row))
        {
            var projected = TProjection.Project(in row);
            TNext.Process(in projected, ref runtime);
        }
    }
}

于是像下面這種常見的查詢：

SELECT Name FROM $ WHERE City = 'Seattle'

最終就會(huì)是：

WhereSelect<...> → Stop<...>

也就是說：一個(gè)循環(huán)里完成過濾和投影，不需要再分兩趟。并且，我們的優(yōu)化器還能識(shí)別更復(fù)雜的嵌套結(jié)構(gòu)，盡可能地把 Where 和 Select 融合在一起，減少中間步驟，提升性能。而這并不需要復(fù)雜的優(yōu)化算法，只需要簡單地把泛型參數(shù)取出來重新帶入到新的融合類型即可，實(shí)現(xiàn)起來非常簡單。

結(jié)果轉(zhuǎn)換

管道把所有行跑完之后，最后還得把結(jié)果以某種形式“交出去”。

一個(gè)查詢的入口長這樣：

internal static class QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>
    where TPipeline : IQueryNode<TRow, TRuntimeResult, TRow>
{
    public static IReadOnlyList<TPublicResult> Execute(ReadOnlySpan<TRow> rows)
    {
        var runtime = new QueryRuntime<TRuntimeResult>(rows.Length);
        TPipeline.Run(rows, ref runtime);

        return ConvertResult(ref runtime);
    }

    private static IReadOnlyList<TPublicResult> ConvertResult(ref QueryRuntime<TRuntimeResult> runtime)
    {
        if (typeof(IReadOnlyList<TRuntimeResult>) == typeof(IReadOnlyList<TPublicResult>))
        {
            return (IReadOnlyList<TPublicResult>)(object)runtime.Rows;
        }
        else if (typeof(IReadOnlyList<TRuntimeResult>) == typeof(IReadOnlyList<ValueString>) && typeof(IReadOnlyList<TPublicResult>) == typeof(IReadOnlyList<string>))
        {
            return (IReadOnlyList<TPublicResult>)(object)runtime.AsStringRows();
        }
        else if (RuntimeFeature.IsDynamicCodeSupported && typeof(TRuntimeResult).IsGenericType && typeof(TPublicResult).IsGenericType)
        {
            return runtime.AsValueTupleRows<TPublicResult>();
        }

        throw new InvalidOperationException($"Cannot convert query result from '{typeof(TRuntimeResult)}' to '{typeof(TPublicResult)}'.");
    }
}

可以看到主要有三種情況：

運(yùn)行時(shí)結(jié)果類型和公共結(jié)果類型一模一樣→ 直接把 Rows 返回就行。
運(yùn)行時(shí)內(nèi)部用的是 ValueString，外面希望看到 string→ 調(diào)用 AsStringRows，它會(huì)把內(nèi)部的 ValueString[] 包裝一下，對外返回 string?（靠隱式轉(zhuǎn)換）。
兩邊都是某種 ValueTuple 形狀→ 用 AsValueTupleRows<TPublicResult>()，底層交給 ValueTupleConvertHelper 去做拷貝和字段轉(zhuǎn)換。

ValueTupleConvertHelper：用動(dòng)態(tài) IL 在元組之間搬運(yùn)字段

ValueTupleConvertHelper<TPublicResult, TRuntimeResult> 的職責(zé)是：

在兩個(gè)兼容形狀的 ValueTuple 之間搬運(yùn)字段；
識(shí)別并處理 string ↔ ValueString 的轉(zhuǎn)換；
如果 ValueTuple 有 Rest（嵌套元組），要遞歸下去做同樣的事情。

它在類型初始化時(shí)，會(huì)生成一個(gè) DynamicMethod 來做拷貝：

internal static class ValueTupleConvertHelper<TPublicResult, TRuntimeResult>
{
    private delegate void CopyDelegate(ref TPublicResult dest, ref readonly TRuntimeResult source);

    private static readonly CopyDelegate _helper = default!;

    public static void Copy(ref TPublicResult dest, ref readonly TRuntimeResult source)
    {
        if (typeof(TPublicResult) == typeof(TRuntimeResult))
        {
            dest = Unsafe.As<TRuntimeResult, TPublicResult>(ref Unsafe.AsRef(in source));
        }
        else
        {
            _helper.Invoke(ref dest, in source);
        }
    }

    static ValueTupleConvertHelper()
    {
        // 構(gòu)造 DynamicMethod 和 IL，按字段復(fù)制，
        // 若發(fā)現(xiàn) string <-> ValueString，就做對應(yīng)轉(zhuǎn)換，
        // 遇到 Rest 字段時(shí)遞歸。
    }
}

這樣，運(yùn)行時(shí)內(nèi)部可以用一個(gè)對自己更舒服的元組類型，比如 (ValueString, int, ValueString, …)，而外面看到的則是 (string, int, string, …)，兩者之間通過這一層幫助類橋接，成本也很低。這使得查詢過程可以最大化利用值類型的泛型特化優(yōu)勢，同時(shí)對外還不需要暴露這些內(nèi)部細(xì)節(jié)，達(dá)到了性能和易用性的平衡。

不過需要注意的是，這一塊用到了動(dòng)態(tài)代碼生成，所以在一些受限環(huán)境（比如 AOT）下可能無法使用，因此 TypedSql 會(huì)在編譯階段檢查這一點(diǎn)，確保只有在支持動(dòng)態(tài)代碼的環(huán)境下，才允許使用這種元組轉(zhuǎn)換。否則的話，就只能退回到直接讓運(yùn)行時(shí)結(jié)果類型和公共結(jié)果類型一致的方式。

整體流程：編譯并執(zhí)行查詢

站在使用者的角度，入口一般會(huì)是這樣的：

var compiled = QueryEngine.Compile<Person, string>(
    "SELECT Name FROM $ WHERE City != 'Seattle'");

Compile<TRow, TResult> 在內(nèi)部會(huì)做這么幾件事：

解析 SQL，生成 ParsedQuery；

把 SQL 編譯成：

管道類型 TPipeline；
TRuntimeResult；
TPublicResult；

檢查 TPublicResult 是否和你指定的 TResult 一致；

構(gòu)造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult> 這個(gè)類型；

找到它的靜態(tài)方法 Execute(ReadOnlySpan<TRow>)；

把它變成一個(gè)委托，塞進(jìn) CompiledQuery<TRow, TResult>。

CompiledQuery<TRow, TResult> 本身只是包了一個(gè)委托：

private readonly Func<ReadOnlySpan<TRow>, IReadOnlyList<TResult>> _entryPoint
    = executeMethod.CreateDelegate<Func<ReadOnlySpan<TRow>, IReadOnlyList<TResult>>>();

然后對外暴露：

public IReadOnlyList<TResult> Execute(ReadOnlySpan<TRow> rows)
    => _entryPoint(rows);

得益于 .NET 10 對委托的逃逸分析、去虛擬化和內(nèi)聯(lián)等優(yōu)化，這一層委托調(diào)用可以說幾乎沒有任何開銷。

在 JIT 看來，一旦 Compile 做完這些準(zhǔn)備工作，以后每次 Execute 就只是：

一次直接的靜態(tài)調(diào)用；
調(diào)入一個(gè)所有類型參數(shù)已經(jīng)封死的泛型方法；
這個(gè)方法里面再調(diào)用一串全是 struct 和靜態(tài)方法組成的管道。

最終編譯出來的類型，你既可以直接拿去執(zhí)行，也可以把它輸出到代碼里然后通過 NativeAOT 編譯成原生二進(jìn)制文件，一套代碼同時(shí)支持 JIT 和 AOT！

使用和性能測試

快速上手

和很多輕量級查詢庫類似，TypedSql 的打開方法是：

定義你的行類型，例如：

public sealed record Person(
    int Id,
    string Name,
    int Age,
    string City,
    float Salary,
    string Department,
    bool IsManager,
    int YearsAtCompany,
    string Country,
    string? Team,
    string Level);

為每一列實(shí)現(xiàn)一個(gè) IColumn<Person, TValue>；

把這些列注冊到 Person 對應(yīng)的 schema 里；

然后就可以編譯并運(yùn)行查詢，例如：

// 編譯一次
var wellPaidManagers = QueryEngine.Compile<Person, Person>(
    """
    SELECT * FROM $ 
    WHERE Department = 'Engineering' 
    AND IsManager = true 
    AND YearsAtCompany >= 5 
    AND Salary > 170000 
    AND Country = 'US'
    """);

// 針對不同數(shù)據(jù)集多次執(zhí)行
var result = wellPaidManagers.Execute(allPeople.AsSpan());

要是你只需要一部分列，也可以返回元組：

var seniorTitles = QueryEngine.Compile<Person, (string Name, string City, string Level)>(
    """
    SELECT Name, City, Level FROM $ 
    WHERE Level = 'Senior' AND City = 'Seattle'
    """);

foreach (var (name, city, level) in seniorTitles.Execute(allPeople.AsSpan()))
{
    Console.WriteLine($"{name} in {city} [{level}]");
}

所有重活——解析 SQL、字面量編碼、在類型系統(tǒng)里搭管道——都發(fā)生在編譯查詢這一步。
之后每次 .Execute，都只是跑一遍已經(jīng)專門化好的靜態(tài)管道，沒有任何的運(yùn)行時(shí)分發(fā)，沒有任何的虛擬調(diào)用，不存在任何的反射和裝箱，完全是 JIT 能看懂的強(qiáng)類型、零分配代碼，從而實(shí)現(xiàn)極高的性能。

簡單性能對比

TypedSql 的目標(biāo)并不是炫技用類型，而是想試試看：在保持 SQL 風(fēng)格外殼的情況下，我們能讓生成的代碼離一個(gè)手寫循環(huán)有多近。

一個(gè)非常簡單的 benchmark 就是拿三個(gè)方案做對比：

一條 TypedSql 查詢；
一條等價(jià)的 LINQ 查詢；
一段手寫的 foreach 循環(huán)。

任務(wù)內(nèi)容：

過濾出 City == "Seattle" 的行；
返回它們的 Id。

TypedSql 編譯出來的類型大概是這樣：

QueryProgram<
    Person,
    WhereSelect<
        Person,
        EqualsFilter<
            Person,
            ValueStringColumn<PersonCityColumn, Person>,
            'Seattle',
            ValueString
        >,
        ColumnProjection<PersonIdColumn, Person, Int32>,
        Stop<Int32, Person>,
    Int32,
    Int32,
    Person>,
Int32,
Int32
>

讓我們來看看 RyuJIT 為我們的查詢方案生成了什么樣的機(jī)器碼：

G_M000_IG01:                ; prologue
       push     r15
       push     r14
       push     rdi
       push     rsi
       push     rbp
       push     rbx
       sub      rsp, 40
       mov      rbx, rcx

G_M000_IG02:                ; 分配結(jié)果數(shù)組
       mov      esi, dword ptr [rbx+0x08]
       mov      edx, esi
       mov      rcx, 0x7FFE71F29558
       call     CORINFO_HELP_NEWARR_1_VC
       mov      rdi, rax
       xor      ebp, ebp
       mov      rbx, bword ptr [rbx]
       test     esi, esi
       jle      SHORT G_M000_IG06

G_M000_IG03:                ; 初始化循環(huán)變量
       xor      r14d, r14d

G_M000_IG04:                ; 循環(huán)體
       lea      r15, bword ptr [rbx+r14]
       mov      rcx, gword ptr [r15+0x08]
       mov      rdx, 0x16EB0400D30
       mov      rdx, gword ptr [rdx]
       mov      rdx, gword ptr [rdx+0x08]
       cmp      rcx, rdx
       je       G_M000_IG12
       test     rcx, rcx
       je       SHORT G_M000_IG05
       test     rdx, rdx
       je       SHORT G_M000_IG05
       mov      r8d, dword ptr [rcx+0x08]
       cmp      r8d, dword ptr [rdx+0x08]
       je       SHORT G_M000_IG08

G_M000_IG05:                ; 更新循環(huán)計(jì)數(shù)器
       add      r14, 72
       dec      esi
       jne      SHORT G_M000_IG04

G_M000_IG06:                ; 產(chǎn)生結(jié)果對象
       mov      rcx, 0x7FFE72227600
       call     CORINFO_HELP_NEWSFAST
       mov      rbx, rax
       lea      rcx, bword ptr [rbx+0x08]
       mov      rdx, rdi
       call     CORINFO_HELP_ASSIGN_REF
       mov      dword ptr [rbx+0x10], ebp
       mov      rax, rbx

G_M000_IG07:                ; epilogue
       add      rsp, 40
       pop      rbx
       pop      rbp
       pop      rsi
       pop      rdi
       pop      r14
       pop      r15
       ret

G_M000_IG08:                ; 字符串長度比較
       lea      rax, bword ptr [rcx+0x0C]
       add      rdx, 12
       mov      ecx, dword ptr [rcx+0x08]
       add      ecx, ecx
       mov      r8d, ecx
       cmp      r8, 10
       je       SHORT G_M000_IG10

G_M000_IG09:                ; 字符串內(nèi)容慢速比較
       mov      rcx, rax
       call     [System.SpanHelpers:SequenceEqual(byref,byref,nuint):bool]
       jmp      SHORT G_M000_IG11

G_M000_IG10:                ; 字符串內(nèi)容快速比較
       mov      rcx, qword ptr [rax]
       mov      rax, qword ptr [rax+0x02]
       mov      r8, qword ptr [rdx]
       xor      rcx, r8
       xor      rax, qword ptr [rdx+0x02]
       or       rcx, rax
       sete     al
       movzx    rax, al

G_M000_IG11:                ; 處理比較結(jié)果
       test     eax, eax
       je       SHORT G_M000_IG05

G_M000_IG12:                ; 把匹配的 Id 寫入結(jié)果數(shù)組
       mov      ecx, dword ptr [r15+0x30]
       lea      rax, bword ptr [rdi+0x10]
       lea      edx, [rbp+0x01]
       mov      r15d, edx
       movsxd   rdx, ebp
       mov      dword ptr [rax+4*rdx], ecx
       mov      ebp, r15d
       jmp      G_M000_IG05

注意看 G_M000_IG08 的 r8, 10，這里的 10 就是字符串字面量 'Seattle' 的長度，JIT 直接把我們的字符串字面量的長度常量嵌進(jìn)了機(jī)器碼里；進(jìn)一步當(dāng)長度匹配時(shí)，JIT 又生成了代碼跳轉(zhuǎn)到 G_M000_IG10，這段代碼專門處理長度為 10 的字符串的快速比較路徑。也就是說，JIT 不僅把字面量的值嵌進(jìn)去了，還根據(jù)它生成了專門的代碼路徑！

再注意看循環(huán)計(jì)數(shù)器的更新部分，G_M000_IG05 里的 add r14, 72，這里的 72 就是 sizeof(Person)，JIT 直接把行類型的大小常量也嵌進(jìn)去了，避免了運(yùn)行時(shí)的計(jì)算；而 dec esi 更是直接把遞增的循環(huán)優(yōu)化成了遞減，減少了一次比較指令。

上述代碼的邏輯等價(jià)于：

int length = elements.Length;
Span<int> values = new int[length];
int count = 0;

for (int i = length - 1; i >= 0; i--)
{
    var elem = elements[i];
    var city = elem.City;
    if (city == null)
        continue;

    if (city.Length == 10 && city == "Seattle")
    {
        values[length - 1 - count] = elem.Id;
        count++;
    }
}

return values[..count];

看到了嗎？跟你手寫的循環(huán)幾乎一模一樣！我們的抽象完全被 JIT 優(yōu)化的一干二凈！

上個(gè)跑分結(jié)果：

Method	Mean	Error	StdDev	Gen0	Code Size	Allocated
TypedSql	10.953 ns	0.0250 ns	0.0195 ns	0.0051	111 B	80 B
Linq	27.030 ns	0.1277 ns	0.1067 ns	0.0148	3,943 B	232 B
Foreach	9.429 ns	0.0417 ns	0.0326 ns	0.0046	407 B	72 B

可以看到：TypedSql 在時(shí)間和分配上無限逼近 foreach，遠(yuǎn)遠(yuǎn)超過即使是在 .NET 10 中已經(jīng)被高度優(yōu)化后的 LINQ 的性能。

這也符合我們對它內(nèi)部結(jié)構(gòu)的預(yù)期：

查詢管道是類型層級的，結(jié)構(gòu)在編譯期就定死
列、投影、過濾全是值類型 + 靜態(tài)方法
字符串統(tǒng)一走 ValueString 熱路徑
字面量則通過 ILiteral<T> 嵌在類型參數(shù)里
所有這些都讓 JIT 能夠把代碼特化、展開、內(nèi)聯(lián)，最終生成和手寫循環(huán)幾乎一樣的機(jī)器碼

尾聲

TypedSql 只是一個(gè)簡單的內(nèi)存查詢引擎實(shí)驗(yàn)。它只是圍繞一個(gè)很具體的問題：C# 的類型系統(tǒng)到底能讓我們把多少查詢邏輯搬過去，.NET 又能針對這些類型生成多快的代碼？

于是，在 TypeSql 中，我們實(shí)現(xiàn)了：

把列、投影、過濾全都表示成帶靜態(tài)方法的 struct，并通過接口的靜態(tài)抽象成員來約束它們的行為
把它們組合成一串嵌套的泛型管道節(jié)點(diǎn)（Where、Select、WhereSelect、Stop）
把數(shù)字和字符串字面量都編碼成類型（ILiteral<T>）

最后得到的是一個(gè)小小的、看起來很像 SQL 的內(nèi)存查詢引擎；而在 JIT 眼里，它其實(shí)就是一套可以進(jìn)行高度優(yōu)化的、類型特化后的循環(huán)。

因此答案是肯定的：.NET 的類型系統(tǒng)完全可以用來表達(dá)圖靈完備的邏輯，并且借助 JIT 編譯器的強(qiáng)大優(yōu)化能力，生成非常高效的代碼。

展望未來的應(yīng)用，諸如查詢引擎、DSL 編譯器、甚至是語言運(yùn)行時(shí)等復(fù)雜系統(tǒng)，都可以通過類似的方式來實(shí)現(xiàn)，從而在保持靈活性的同時(shí)，最大化性能。而你甚至不需要實(shí)現(xiàn)任何的代碼生成后端，只要利用好 C# 的泛型和靜態(tài)成員，就能讓 JIT 幫你完成大部分的工作。而把構(gòu)建好的類型輸出成代碼文件，再通過 NativeAOT 編譯成原生二進(jìn)制文件，也同樣是可行的。編寫一次，同時(shí)支持 JIT 和 AOT，兩全其美。并且不同于 C++ 的模板和 constexpr，我們的引擎是完全支持來自外部的動(dòng)態(tài)輸入的，而不需要在編譯時(shí)確定一切！

本項(xiàng)目的代碼已經(jīng)開源在 GitHub 上，歡迎點(diǎn)贊和 Star：https://github.com/hez2010/TypedSql

以上就是詳解如何在C#類型系統(tǒng)上實(shí)現(xiàn)一個(gè)SQL查詢引擎TypedSql的詳細(xì)內(nèi)容，更多關(guān)于C# SQL查詢的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: