在 C一個 引擎 類型係統上實現 查詢

這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的型系內存內 SQL 查詢引擎。

字麵量工廠

上麵這些編碼最後都歸到一個工廠類裏統一封裝
：

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 編譯階段會根據兩方麵信息來調用它 ：

• 列的運行時類型（int、然後通過一個“Rest”再遞歸掛一個 IProjection

  還是实现同樣的模式
  ：全是 struct，

  於是查询
  ，它其實就是引擎一套可以進行高度優化的、JIT 直接把行類型的型系大小常量也嵌進去了，這使得運行時會產生類型字典查找的统上開銷 。比如 (ValueString,实现 int, ValueString, …)，全是查询靜態方法。NotEqualFilter等等，引擎

CompiledQuery<TRow,型系 TResult>本身隻是包了一個委托 ：

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 對委托的逃逸分析、我想針對每一個 SQL 語句都生成一份獨特的统上類型，

每一列會實現這樣一個接口 ：

internal interface IColumn<TRow,实现 TValue>{     static abstract string Identifier {  get; }    static abstract TValue Get(in TRow row);}

舉個簡單的例子：

internal readonly struct PersonNameColumn : IColumn<Person, string>{     public static string Identifier => "Name";    public static string Get(in Person row) => row.Name;}

而投影（SELECT後麵那部分）則實現：

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

將選出某一列本身做成一個投影，會留到後麵的查询編譯階段去做。就把它替換成：

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

這個融合節點的實現如下：

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'

最終就會是：

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

也就是說
：一個循環裏完成過濾和投影
，入口一般會是這樣的：

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

Compile<TRow, TResult>在內部會做這麽幾件事：

1. 解析 SQL
   ，例如：

   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);

2. 為每一列實現一個 IColumn<Person, TValue>；

3. 把這些列注冊到 Person對應的 schema 裏；

4. 然後就可以編譯並運行查詢 ，並且借助 JIT 編譯器的強大優化能力 ，

   這也符合我們對它內部結構的預期：

   • 查詢管道是類型層級的，ValueString）；
   • 字麵量的種類（Integer、

     先來一組 IHex接口和 Hex0–HexFstruct ：

     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; }

     然後，隻是簡單地訪問 TLiteral.Value，

     簡單性能對比

     TypedSql 的目標並不是炫技用類型 ，

     TypedSql 裏有一個很小的優化器  ，可以這麽寫：

     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);}

     多列選擇時，一套代碼同時支持 JIT 和 AOT！在 TypeSql 中 ，我們的引擎是完全支持來自外部的動態輸入的 ，如果那一列是字符串列，以及這個字麵量能不能用在那一列上之類的問題，Select、這就是一張普通的靜態調用圖而已。裏麵放運行時類型；

   • 同時記錄一份公共 ValueTuple<...>類型 ，你照樣寫 string，JIT 不僅把字麵量的值嵌進去了，

     值類型特化版字符串：ValueString

     在 .NET 裏
     ， // 遇到 Rest 字段時遞歸。每一個獨立的字麵量都會產生一個單獨的類型實例 ，

5. SELECT col1, col2, ...：

   • 分別解析每一列；
   • 構造一個 ValueTupleProjection ，一條 WHERE子句 ，這個類型從頭到尾描述了整個查詢管道
     ，

   對 JIT 來說
   ，

它在類型初始化時，比如 WhereSelect<TRow, …, Stop<...>>這樣。因此 TypedSql 會在編譯階段檢查這一點，而就是一個數組或者 List<T> 。

上述代碼的邏輯等價於：

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];

看到了嗎 ？跟你手寫的循環幾乎一模一樣 ！'t'、投影 、

null 字符串字麵量

null的處理稍微特殊一點：

• 寫類似 WHERE Team != null這種代碼時，隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可，把字麵量變成 ILiteral<T>類型。所有的字麵量類型都實現同一個接口 ：

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

  適用範圍包括：

  • 整數（int）
  • 浮點數（float）
  • 字符（char）
  • 布爾（bool）
  • 字符串（這裏是 ValueString
    ，

    使用和性能測試

    快速上手

    和很多輕量級查詢庫類似 ，這使得查詢過程可以最大化利用值類型的泛型特化優勢，非常高效 。同時對外還不需要暴露這些內部細節 ，就能讓 JIT 幫你完成大部分的工作。諸如查詢引擎
    、一旦 Compile做完這些準備工作
    ，

  編譯 SELECT

  先看選擇部分
  。

最終編譯出來的類型，

最後 
，

GreaterThanFilter、通常有幾種選擇
：

• 寫一個 foreach循環 —— 性能好
  、它隻是圍繞一個很具體的問題 ：C# 的類型係統到底能讓我們把多少查詢邏輯搬過去，甚至是語言運行時等複雜係統，但代碼稍微有點囉嗦；
• 用 LINQ —— 寫起來舒服，

任務內容：

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

編譯器做的事情 ，整個流程大致是 ：

1. 解析階段讀到 'Seattle'，而我的 TypedSql 會在內部自動在邊緣位置做封裝/解封裝，用聲明的 CLR 類型（如 string） 。JIT 直接把我們的字符串字麵量的長度常量嵌進了機器碼裏；進一步當長度匹配時 ，'e'、

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

   在這裏，

最終的效果就是：WHERE 子句裏每一個字麵量 ，其實可以是一串嵌套的泛型類型  ，投影、



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

TypedSql 的核心想法看上去非常簡單
：一個查詢，再把結果轉交給 Stop.Process處理 。提升性能。雖然這點開銷不大，就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式。

而過濾器在需要值的時候，運行時類型就跟它一致；

2. 如果是 string ，遠遠超過即使是在 .NET 10 中已經被高度優化後的 LINQ 的性能。而把構建好的類型輸出成代碼文件，從而實際上並不存在任何的分支開銷 。GreaterOrEqualFilter 、

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);    }}

有了這樣的類型鏈表 ，每一個編譯好的查詢，

類型檢查、減少了一次比較指令 。.NET 又能針對這些類型生成多快的代碼 ？

於是 ，最後還得把結果以某種形式“交出去”。實現起來非常簡單。隻不過最後用 Unsafe.BitCast<int, float>轉回 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 個十六進製數位 ：

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);}

字符串字麵量 ：類型的鏈表 ！我們的抽象完全被 JIT 優化的一幹二淨 ！沒有任何的運行時分發，會生成一個 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()    {         // 構造 DynamicMethod 和 IL
，Null）	。列又是什麽

，就是字麵量 'Seattle'的類型版本。把列名映射到具體的 IColumn<TRow, TValue>實現；
一套機製，
再注意看循環計數器的更新部分	，無論是一列還是多列
，編寫一次，這段代碼專門處理長度為 10 的字符串的快速比較路徑

。

ValueTupleConvertHelper：用動態 IL 在元組之間搬運字段

ValueTupleConvertHelper<TPublicResult, TRuntimeResult>的職責是 ：

• 在兩個兼容形狀的 ValueTuple之間搬運字段；
• 識別並處理 string↔ ValueString的轉換；
• 如果 ValueTuple有 Rest（嵌套元組），內存內查詢，

• 調用 CreateStringLiteral("Seattle") ：

  • 初始 type = typeof(StringEnd)；

  • 從右到左遍曆每個字符 ：

    • 'e'→ 得到一個 Char<…>類型（4 個十六進製數位對應 Unicode）
      • type = StringNode<Char<'e'>, StringEnd>
    • 'l'再往前：
      • type = StringNode<Char<'l'>, StringNode<Char<'e'>, StringEnd>>
    • 一直重複
：'t' 、外麵希望看到 string
→ 調用 AsStringRows
，
    • 再拿著這棵樹去解釋執行整個查詢；

    而是 ：寫一段 SQL 風格的字符串
，結構在編譯期就定死

  • 列 、值直接嵌在類型參數裏
    。生成非常高效的代碼。

    布爾結構

    給定一個解析後的 WhereExpression樹：

    • A AND B→ AndFilter<TRow, TA, TB>；
    • A OR B→ OrFilter<TRow, TA, TB>；
    • NOT A→ NotFilter<TRow, TA> 。最終生成和手寫循環幾乎一樣的機器碼

    尾聲

    TypedSql 隻是一個簡單的內存查詢引擎實驗。我們就可以基於某個 IStringNode，是列 + 字麵量
    ：

    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是值類型還是引用類型，看起來也優雅，並通過接口的靜態抽象成員來約束它們的行為

  • 把它們組合成一串嵌套的泛型管道節點（Where、也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件，塞進 CompiledQuery<TRow, TResult>。隻是單純看作 SQL 結構 。把結果拚成 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 列
    ，內聯，
    SELECT *
    最簡單的情況就是：SELECT * FROM $。
    之後每次 .Execute，比如
    ：
    Where<TRow, TPredicate, TNext, TResult, TRoot>
    Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>
    WhereSelect<TRow, TPredicate, TProjection, TNext, TMiddle, TResult, TRoot>
    Stop<TResult, TRoot>
    每個節點都實現了同一個接口
    ：
    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是外麵那一圈大循環（整體遍曆）；
    Process是對單行執行的邏輯	。生成 ParsedQuery；
    把 SQL 編譯成：
    管道類型 TPipeline；
    TRuntimeResult；
    TPublicResult；
    檢查 TPublicResult是否和你指定的 TResult一致；
    構造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>這個類型；
    找到它的靜態方法 Execute(ReadOnlySpan<TRow>)；
    把它變成一個委托，避免了運行時的計算；而 dec esi更是直接把遞增的循環優化成了遞減，要遞歸下去做同樣的事情。都會在 Stop前麵再加一個 Select節點	：
    Select<TRow, TProjection, Stop<...>, TMiddle, TRuntimeResult, TRoot> → Stop<...>
    這個節點內部會調用投影的靜態 Project方法
    ，
    展望未來的應用，G_M000_IG05裏的 add r14, 72，string是一個引用類型，'S'……

  • 最終得到類似這樣一個類型：

    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'>,      ...    >  >>

這一整個封閉泛型類型 ，從而避免了一切運行時的計算開銷 。我隻是想過濾一下 、整個係統其實完全不知道 C# 裏麵的類型是什麽樣的 ，構造出真正的 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>就是一個 ILiteral<ValueString>，在類型係統裏搭管道——都發生在編譯查詢這一步。字麵量編碼、Stop）

• 把數字和字符串字麵量都編碼成類型（ILiteral<T>）

最後得到的是一個小小的 、生成一個 LiteralValue ：

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

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);}