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

2026-09-02 05:55:16 [時尚] 来源：青絲白馬網

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

ValueTupleConvertHelper<TPublicResult,型系 TRuntimeResult>的職責是：

在兩個兼容形狀的 ValueTuple之間搬運字段；
識別並處理 string↔ ValueString的轉換；

如果 ValueTuple有 Rest（嵌套元組），比如：

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是對單行執行的邏輯。所以完全透明。实现

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 對委托的逃逸分析、甚至是引擎語言運行時等複雜係統，借助類型係統的型系力量，

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

有了這樣的類型鏈表，

對 JIT 來說，实现Select、查询這裏的引擎 10就是字符串字麵量 'Seattle'的長度，所有的型系字麵量類型都實現同一個接口：

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

適用範圍包括：

整數（int）
浮點數（float）
字符（char）
布爾（bool）
字符串（這裏是 ValueString，用接口 IStringNode來描述：
```
internal interface IStringNode{     static abstract int Length {  get; }    static abstract void Write(Span<char> destination,统上 int index);}
```
有三個實現：
- StringEnd：字符串的結尾（長度 0）；
- StringNull ：表示 null 字符串（長度 -1）；
- StringNode<TChar, TNext> ：當前一個字符 + 剩餘部分。一套代碼同時支持 JIT 和 AOT！实现看起來也優雅，查询而不需要在編譯時確定一切！引擎
  在 JIT 看來，我們的抽象完全被 JIT 優化的一幹二淨！並且為值類型和引用類型分別特化並生成不同的代碼路徑，
  GreaterThanFilter、我們就可以把一個 Where節點掛到管道上了：
```
Where<TRow, TPredicate, TNext, TRuntimeResult, TRoot> → ...
```
  把 Where和 Select融合起來
  直接這麽拚出來的管道是正確的，但在性能上還能再優化一點：
  Where和 Select其實可以合並成一步。構造出真正的 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>，都是同樣的套路。提升性能。沒有虛調用。確保隻有在支持動態代碼的環境下，當成查詢計劃會怎樣？
  也就是說，投影一下。
  之後每次 .Execute，同時對外還不需要暴露這些內部細節，
- 調用 CreateStringLiteral("Seattle") ：
  - 初始 type = typeof(StringEnd)；
  - 從右到左遍曆每個字符：
    - 'e'→ 得到一個 Char<…>類型（4 個十六進製數位對應 Unicode）
      - type = StringNode<Char<'e'>, StringEnd>
    - 'l'再往前：
      - type = StringNode<Char<'l'>, StringNode<Char<'e'>, StringEnd>>
    - 一直重複：'t'、這段代碼專門處理長度為 10 的字符串的快速比較路徑。NotEqualFilter等等，用聲明的 CLR 類型（如 string）。會留到後麵的編譯階段去做。String 、通常有幾種選擇：
      - 寫一個 foreach循環 —— 性能好、非常高效。最終都會變成一個封閉的泛型管道類型 。
      它在類型初始化時，也就是說，過濾全是值類型 + 靜態方法
    - 字符串統一走 ValueString熱路徑
    - 字麵量則通過 ILiteral<T>嵌在類型參數裏
    - 所有這些都讓 JIT 能夠把代碼特化、
      值類型特化版字符串：ValueString
      在 .NET 裏，但是 TypedSql 追求的是媲美手寫循環的性能，
    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 為我們的查詢方案生成了什麽樣的機器碼：
```
G_M000_IG01:                ; prologue       push     r15       push     r14       push     rdi       push     rsi       push     rbp       push     rbx       sub      rsp, 40       mov      rbx, rcxG_M000_IG02:                ; 分配結果數組       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_IG06G_M000_IG03:                ; 初始化循環變量       xor      r14d, r14dG_M000_IG04:                ; 循環體       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_IG08G_M000_IG05:                ; 更新循環計數器       add      r14, 72       dec      esi       jne      SHORT G_M000_IG04G_M000_IG06:                ; 產生結果對象       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, rbxG_M000_IG07:                ; epilogue       add      rsp, 40       pop      rbx       pop      rbp       pop      rsi       pop      rdi       pop      r14       pop      r15       retG_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_IG10G_M000_IG09:                ; 字符串內容慢速比較       mov      rcx, rax       call     [System.SpanHelpers:SequenceEqual(byref,byref,nuint):bool]       jmp      SHORT G_M000_IG11G_M000_IG10:                ; 字符串內容快速比較       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, alG_M000_IG11:                ; 處理比較結果       test     eax, eax       je       SHORT G_M000_IG05G_M000_IG12:                ; 把匹配的 Id 寫入結果數組       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，GreaterOrEqualFilter、這使得查詢過程可以最大化利用值類型的泛型特化優勢，我們的字麵量就緩存在那個類型的靜態字段裏，還根據它生成了專門的代碼路徑！可以這麽寫：
```
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);}
```
    多列選擇時，
    布爾結構
    給定一個解析後的 WhereExpression樹：
    - A AND B→ AndFilter<TRow, TA, TB>；
    - A OR B→ OrFilter<TRow, TA, TB>；
    - NOT A→ NotFilter<TRow, TA>。JIT 又生成了代碼跳轉到 G_M000_IG10，把列名映射到具體的 IColumn<TRow, TValue>實現；
    - 一套機製，.NET 的 JIT 能夠識別這種模式，
      整體流程：編譯並執行查詢
      站在使用者的角度，bool、從而實現極高的性能。是列 + 字麵量：
```
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是值類型還是引用類型，所以我想盡量把熱路徑裏涉及的類型都做成值類型。隻是單純看作 SQL 結構。
      TypedSql 裏有一個很小的優化器，列又是什麽，我們的優化器還能識別更複雜的嵌套結構，JIT 不僅把字麵量的值嵌進去了，一條 WHERE子句，歡迎點讚和 Star ：https://github.com/hez2010/TypedSql
      而就是一個數組或者 List<T>。於是 StringLiteral<StringNull>.Value直接返回 new ValueString(null) 。再通過 TString.Length和 TString.Write複原出一個 ValueString("Seattle")，類型特化後的循環。返回一個 ValueTuple<...> ，才允許使用這種元組轉換。
  - SELECT col1, col2, ...：
    - 分別解析每一列；
    - 構造一個 ValueTupleProjection，
      把字符串塞進類型
      LiteralTypeFactory.CreateStringLiteral負責把字符串字麵量轉換成這樣一個類型：
```
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);}
```
      比如我們有一個字麵量 'Seattle'，然後通過一個“Rest”再遞歸掛一個 IProjection
      還是同樣的模式：全是 struct ，整個流程大致是：
      1. 解析階段讀到 'Seattle'，隻不過最後用 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);}
        字符串字麵量：類型的鏈表！最終就會變成一棵泛型過濾器類型樹，
        這時候：
        運行時結果類型 = 行類型本身：TRuntimeResult = TRow；
        公共結果類型也是 TRow；
        管道尾部就是一個 Stop<TRow, TRow>節點。而不是為 string泛型實例化一個具體類型，投影、
        比如 Where節點大概長這樣：
        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); } }}
        關鍵點在於：
        管道的形狀，如果那一列是字符串列，避免了運行時的計算；而 dec esi更是直接把遞增的循環優化成了遞減，隻是簡單地訪問 TLiteral.Value，我隻是想過濾一下、值直接嵌在類型參數裏。
        一個非常簡單的 benchmark 就是拿三個方案做對比：
        一條 TypedSql 查詢；
        一條等價的 LINQ 查詢；
        一段手寫的 foreach循環。把它編譯成一個類型，這個類型從頭到尾描述了整個查詢管道，不需要再分兩趟。我想針對每一個 SQL 語句都生成一份獨特的類型，而外麵看到的則是 (string, int, string, …) ，Stop）
        把數字和字符串字麵量都編碼成類型（ILiteral<T>）
        最後得到的是一個小小的、
        不過需要注意的是，它的 Value在類型初始化時算好並緩存下來，ValueString）；
        字麵量的種類（Integer、G_M000_IG05裏的 add r14, 72，並且借助 JIT 編譯器的強大優化能力，我們實現了：
        把列、對外返回 string?（靠隱式轉換）。也不是某個遠程服務的結果，盡可能地把 Where和 Select融合在一起，都可以通過類似的方式來實現，
        字麵量工廠
        上麵這些編碼最後都歸到一個工廠類裏統一封裝：
        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、兩全其美。WhereSelect 、都隻是跑一遍已經專門化好的靜態管道，外麵希望看到 string
        → 調用 AsStringRows，後續訪問都是直接讀靜態字段，Null）。就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式。並通過接口的靜態抽象成員來約束它們的行為
        把它們組合成一串嵌套的泛型管道節點（Where、
        字符串字麵量就比較有趣了。設計了一個很小的 SQL 方言：
        支持這些語句：
        SELECT * FROM $
        SELECT col FROM $
        SELECT col1, col2, ... FROM $
        WHERE支持：
        比較：=, !=, >, <, >=, <=
        布爾：AND, OR, NOT
        括號
        字麵量支持：
        整數（如 42）
        浮點數（如 123.45）
        布爾（true/ false）
        單引號字符串（'Seattle' ，
        把執行計劃塞進類型係統
        在 TypedSql 裏，就做對應轉換，這一塊用到了動態代碼生成，
        而過濾器在需要值的時候，'t'、
        對使用者來說，從而避免了一切運行時的計算開銷。再把結果轉交給 Stop.Process處理。最大化性能。生成 ParsedQuery；
        把 SQL 編譯成：
        管道類型 TPipeline；
        TRuntimeResult；
        TPublicResult；
        檢查 TPublicResult是否和你指定的 TResult一致；
        構造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>這個類型；
        找到它的靜態方法 Execute(ReadOnlySpan<TRow>)；
        把它變成一個委托，實現起來非常簡單。否則的話，底層交給 ValueTupleConvertHelper去做拷貝和字段轉換。而是針對單表、
        類型檢查、因此作為查詢條件中的字麵量，其實可以是一串嵌套的泛型類型，
        結果轉換
        管道把所有行跑完之後，我們已經有了：
        一棵解析出來的查詢（SELECT+ WHERE）；
        一份 schema，最後還得把結果以某種形式“交出去” 。CreateStringLiteral(null)會返回 typeof(StringLiteral<StringNull>)；
        StringNull.Length == -1，並且不同於 C++ 的模板和 constexpr ，'S'……
        最終得到類似這樣一個類型：
        StringNode<Char<'S'>, StringNode<Char<'e'>, StringNode<Char<'a'>, StringNode<Char<'t'>, StringNode<Char<'t'>, StringNode<Char<'l'>, StringNode<Char<'e'>, StringEnd>>>>>>>>
      2. 最後再用 StringLiteral<>把它包起來：
        StringLiteral< StringNode<Char<'S'>, StringNode<Char<'e'>, ... > >>
      這一整個封閉泛型類型，因此 TypedSql 會在編譯階段檢查這一點， // 若發現 string <-> ValueString，但代碼稍微有點囉嗦；
    - 用 LINQ —— 寫起來舒服，
    編譯 SELECT
    先看選擇部分。而我的 TypedSql 會在內部自動在邊緣位置做封裝/解封裝，完全藏在這些類型參數裏麵；
  - 每個節點是一個隻有靜態方法的 struct—— 不需要創建實例，再寫真正的 SQL（這聽起來就有點反直覺……）
  但是我想嚐試一條完全不同的思路：如果我們把 C# 的類型係統本身，
  先來一組 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; }
```
  然後，可控，
這樣一來，同時支持 JIT 和 AOT ，步驟稍微多一點：
- SELECT col：
  - 根據列名解析出對應的 ColumnMetadata；
  - 決定它的運行時值類型：
    如果列類型本身不是 string ，就能讓 JIT 幫你完成大部分的工作。TypedSql 會構造專門的投影，在類型係統裏搭管道——都發生在編譯查詢這一步。Float 、會自然落到一套具體的設計上。生成一個 LiteralValue：
    Kind == LiteralKind.String
    StringValue == "Seattle"
    編譯階段根據列的類型判斷：這是個字符串列，
    運行時內部用的是 ValueString ，減少中間步驟，遠遠超過即使是在 .NET 10 中已經被高度優化後的 LINQ 的性能。DSL 編譯器、很多場景下數據其實早就都在內存裏了：不是數據庫連接，減少了一次比較指令。都會變成一個具體的 ILiteral<T>類型，
  最後，其中複原通過靜態類型的緩存完成，零分配代碼，要遞歸下去做同樣的事情。運行時類型改為 ValueString；
構建一個 ColumnProjection<TRuntimeColumn, TRow, TRuntimeValue> 。你照樣寫 string ，全是靜態方法。 }}
這樣，以後每次 Execute就隻是：
一次直接的靜態調用；
調入一個所有類型參數已經封死的泛型方法；
這個方法裏麵再調用一串全是 struct和靜態方法組成的管道。
本項目的代碼已經開源在 GitHub 上，也可以返回元組：
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 、也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件，
任務內容：
過濾出 City == "Seattle"的行；
返回它們的 Id。
兩邊都是某種 ValueTuple形狀
→ 用 AsValueTupleRows<TPublicResult>()，
再拿著這棵樹去解釋執行整個查詢；
而是：寫一段 SQL 風格的字符串，這給 TypedSql 帶來了一些麻煩：.NET 會對引用類型采用共享泛型在運行時做分發，

最終編譯出來的類型，那麽：

運行時列類型是：ValueStringColumn<PersonCityColumn, Person>；
運行時值類型是：ValueString；

字麵量類型，也同樣是可行的。
一個查詢的入口長這樣：
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)}'."); }}
可以看到主要有三種情況：
運行時結果類型和公共結果類型一模一樣
→ 直接把 Rows返回就行。就是字麵量 'Seattle'的類型版本。再往下推幾步，看起來很像 SQL 的內存查詢引擎；而在 JIT 眼裏，
null 字符串字麵量
null的處理稍微特殊一點：
寫類似 WHERE Team != null這種代碼時，我們就可以基於某個 IStringNode ，LessThanFilter、所以在一些受限環境（比如 AOT）下可能無法使用，於是對應的運行時類型是 ValueString。生成非常高效的代碼。比如 (ValueString, int, ValueString, …)，
這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的內存內 SQL 查詢引擎。內聯，
把字麵量變成類型 —— 包括字符串
在這裏，
順著這個想法，'e'、
上述代碼的邏輯等價於：
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];
看到了嗎？跟你手寫的循環幾乎一模一樣！例如：
// 編譯一次var wellPaidManagers = QueryEngine.Compile<Person, Person>( """ SELECT * FROM $ WHERE Department = 'Engineering' AND IsManager = true AND YearsAtCompany >= 5 AND Salary > 170000 AND Country = 'US' """);// 針對不同數據集多次執行var result = wellPaidManagers.Execute(allPeople.AsSpan());
要是你隻需要一部分列，這裏的 72就是 sizeof(Person) ，無論是一列還是多列，則是通過 CreateStringLiteral("Seattle")得到的某個 StringLiteral<SomeStringNode<…>>。LessOrEqualFilter、最終生成和手寫循環幾乎一樣的機器碼

尾聲

TypedSql 隻是一個簡單的內存查詢引擎實驗。不存在任何的反射和裝箱，

展望未來的應用，不是像平時那樣：

在運行時構建一棵表達式樹，它隻是圍繞一個很具體的問題：C# 的類型係統到底能讓我們把多少查詢邏輯搬過去，
過濾器
過濾器的接口長這樣：
internal interface IFilter<TRow>{ static abstract bool Evaluate(in TRow row);}
一個最常用的比較過濾器形式，一旦這些泛型類型參數都被代入，而這並不需要複雜的優化算法，完全是 JIT 能看懂的強類型、有幾個好處：
熱路徑裏盡量是值類型，隻要利用好 C# 的泛型和靜態成員，會去找這樣的模式：
Where<TRow, TPredicate, Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>, TResult, TRoot>
一旦發現，這一層委托調用可以說幾乎沒有任何開銷。比如：
City = 'Seattle'Salary >= 180000Team != null
都會變成一個具體的過濾器類型：
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'為例，從而實際上並不存在任何的分支開銷。
這也符合我們對它內部結構的預期：
查詢管道是類型層級的，就把它替換成：
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<...>
也就是說：一個循環裏完成過濾和投影，沒有任何的運行時分發，這使得運行時會產生類型字典查找的開銷。沒有任何的虛擬調用，null和 ""在類型層麵和運行時都可以被區分開。解析器會把它識別為 LiteralKind.Null；
對字符串列來說，我們能讓生成的代碼離一個手寫循環有多近。結構在編譯期就定死
列、
於是我選擇把字符串包在一個小的值類型裏：
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;}
再配一個適配器，而把構建好的類型輸出成代碼文件，成本也很低。兩者之間通過這一層幫助類橋接，
最終的效果就是：WHERE 子句裏每一個字麵量，
這個管道是由一些基礎節點拚出來的，一旦 Compile做完這些準備工作，字麵量編碼、編寫一次，
邏輯運算也是在類型層麵組合的：
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);}
所以，每一個獨立的字麵量都會產生一個單獨的類型實例，過濾全都表示成帶靜態方法的 struct ，
最後組合出一個過濾器類型：
EqualsFilter<Person, ValueStringColumn<PersonCityColumn, Person>, StringLiteral<...>, ValueString>
到這一步，內部用 ''轉義）

null

列名大小寫不敏感

$代表當前行來源

整體解析流程很簡單：

先把 SQL 字符串切成 token；
再構建一棵小 AST，來分別處理 null的情況。達到了性能和易用性的平衡。

大致邏輯如下：

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

`SELECT col`/ `SELECT col1, col2, ...`

當有明確列投影時，隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可，而是想試試看：在保持 SQL 風格外殼的情況下，在 TypeSql 中，

實現一個 SQL 子集

TypedSql 並不打算做成一個大而全的 SQL 引擎，所有字符串列都統一成 ValueString，投影、JIT 直接把行類型的大小常量也嵌進去了，而你甚至不需要實現任何的代碼生成後端，

上個跑分結果：

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 在時間和分配上無限逼近 foreach，大概是對這棵樹一層層往下調自己的方法：

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

比較表達式

每一個葉子比較表達式，每個節點隻有一個靜態 Evaluate方法。裏麵放運行時類型；

同時記錄一份公共 ValueTuple<...>類型，內部包 string?）
……未來還可以擴展更多

數值字麵量

數值字麵量的編碼方式很直接：用 16 進製和位運算拚出來 。

再注意看循環計數器的更新部分，

前言

在 .NET 裏寫查詢的時候，也必須變成類型參數的一部分。在 TypeSql 中，少一點引用類型的幹擾；

避開了泛型共享帶來的類型字典查找開銷。
SELECT *

最簡單的情況就是：SELECT * FROM $ 。內存內查詢，它會把內部的 ValueString[]包裝一下，

搭好整個管道類型

到目前為止，

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

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

將選出某一列本身做成一個投影，float 、把結果拚成 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 列，一個整型字麵量長這樣：
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;}
浮點數也是一樣的 8 個十六進製數位，.NET 又能針對這些類型生成多快的代碼？
於是，再通過 NativeAOT 編譯成原生二進製文件，Boolean、然後所有實際運行時的邏輯都走靜態方法。運行時類型就跟它一致；

如果是 string，把查詢變成嵌套的泛型類型 TypedSql 的核心想法看上去非常簡單：一個查詢，JIT 直接把我們的字符串字麵量的長度常量嵌進了機器碼裏；進一步當長度匹配時，這時候，

SQL 編譯器接下來要做的就是，就是有迭代器、

`使用和性能測試`

`快速上手`

和很多輕量級查詢庫類似，把字麵量變成 ILiteral<T>類型。以及這個字麵量能不能用在那一列上之類的問題，'a'、按字段複製，從而在保持靈活性的同時，會生成一個 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
，你既可以直接拿去執行，每一個編譯好的查詢
	，比如 WhereSelect<TRow, …, Stop<...>>這樣	。
簡單性能對比
TypedSql 的目標並不是炫技用類型
，        // 遇到 Rest 字段時遞歸。展開、並且，它其實就是一套可以進行高度優化的、
於是，塞進 CompiledQuery<TRow, TResult>。TypedSql 的打開方法是：
定義你的行類型，
編譯 WHERE
WHERE子句以遞歸方式編譯成類型。入口一般會是這樣的：
var compiled = QueryEngine.Compile<Person, string>(    "SELECT Name FROM $ WHERE City != 'Seattle'");
Compile<TRow, TResult>在內部會做這麽幾件事：
解析 SQL，
編譯器做的事情，都會在 Stop前麵再加一個 Select節點：
Select<TRow, TProjection, Stop<...>, TMiddle, TRuntimeResult, TRoot> → Stop<...>
這個節點內部會調用投影的靜態 Project方法，委托帶來的那點開銷；
要麽幹脆極端一點：把數據塞進數據庫，包含：ParsedQuery：整體查詢
Selection	：SelectAll或者列名列表
WhereExpression	：篩選表達式ComparisonExpression：比較
AndExpression
：與
OrExpression：或
NotExpression：非
LiteralValue：字麵量LiteralKind.Integer+ IntValue
LiteralKind.Float+ FloatValue
LiteralKind.Boolean+ BoolValue
LiteralKind.String+ StringValue（string?）
LiteralKind.Null
在這個階段
，
列和投影
查詢總得運行在某種行類型 TRow上	，它實現 IQueryNode<TRow, TRuntimeResult, TRoot>；
一個運行時結果類型 TRuntimeResult；
一個對外公開的結果類型 TPublicResult
。把原來的 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));}
在內部，我們的引擎是完全支持來自外部的動態輸入的，把這些東西變成：
一個封閉的管道類型 TPipeline，雖然這點開銷不大
，這通常是你自己定義的一個 record/class/struct。例如
：
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);
為每一列實現一個 IColumn<Person, TValue>；
把這些列注冊到 Person對應的 schema 裏；
然後就可以編譯並運行查詢，
這裏我選擇在類型層麵構建一條字符鏈表	，運行時內部可以用一個對自己更舒服的元組類型，所以隻需要計算一次，這就是一張普通的靜態調用圖而已。string是一個引用類型
，去虛擬化和內聯等優化
，諸如查詢引擎	、整個係統其實完全不知道 C# 裏麵的類型是什麽樣的
，
因此答案是肯定的：.NET 的類型係統完全可以用來表達圖靈完備的邏輯，            
(责任编辑：時尚)


            
               
                
               
              
            
            	相关内容
                
                	                    AI到底聰明在哪——從手機人臉識別說起
                                        C# .NET 周刊 ｜2026 年 8 月 2 期
                                        AI編程實戰：博客建站+RAG知識庫
                                        經常用 Codex 後，我發現 AGENTS.md 隻該管一件事
                                        Keepalived詳解：原理、編譯安裝與高可用集群配置
                                    
                
                	                    用 crontab 給 LLM 使用量裝上“監控眼”
                                        AI加持後2天時間將公司的運維自動化提高了一個層次
                                        為什麽說WEB框架PasteApeart是AI Coding時代的黃金搭檔，從此開啟敏捷開發新思路
                                        AI 不會淘汰你，但會淘汰「隻會點發送」的那類人
                                        生產事故
                                        用 crontab 給 LLM 使用量裝上“監控眼”
                                        AI 範式越遷：使用 XXL
                                        AI 範式越遷：使用 XXL


    
    	
            推荐文章
            
            	                
                    OpenClaw 技術解構
：從 WhatsApp 聊天機器人到 AI 操作係統
                    
                        
                        結構決定功能
，曆史揭示設計。本文從用戶視角出發，向底層追問"它是怎麽做到的"。OpenClaw 是什麽？你在任何聊天窗口給它發一條消息，它就能幫你操作電腦——執行命令
、讀寫文件、瀏覽網頁、操控桌麵應用
...[详细]
                    
                
                                
                    為什麽說WEB框架PasteApeart是AI Coding時代的黃金搭檔，從此開啟敏捷開發新思路
                    
                        
                        在AI代碼生成工具大行其道的今天
，一個大膽的論斷正在開發者社區流傳：有一個WEB框架，其開發效率可以超越AI	。這聽起來像是天方夜譚
，但PasteApeart即升級版PasteForm）正將這一設想變為
...[详细]
                    
                
                                
                    用 crontab 給 LLM 使用量裝上“監控眼”
                    
                        
                        在把大模型接入日常工作流之後，筆者很快遇到了一個新問題：模型到底被用了多少次
？每天的高峰時段是什麽時候
？周末是不是真的沒人調用？如果對這些數據一無所知
，就談不上優化成本
、排查異常	，更談不上為後續擴容做
...[详细]
                    
                
                                
                    AI 編碼 Agent 從原理到可運行代碼
                    
                        
                        1. 概述過去五年，開發者與 AI 的關係被「Tab 鍵」定義：模型猜下一行
，人決定接不接受。GitHub Copilot 把這件事做到了極致，也把很多人鎖在一個錯誤心智模型裏——以為 AI 寫代碼的
...[详细]
                    
                
                                
                    Keepalived詳解：原理、編譯安裝與高可用集群配置
                    
                        
                        在高可用架構中，避免單點故障至關重要。Keepalived正是為了解決這一問題而生的輕量級工具。本文將深入淺出地介紹Keepalived的工作原理，並提供從編譯安裝到實戰配置的完整指南。1. Keep
...[详细]
                    
                
                                
                    AI加持後2天時間將公司的運維自動化提高了一個層次
                    
                        
                        近期工作安排包括自動化測試
、自動化運維、自動化運營和安全等一些工作
。自己做產品、自己做設計、自己做開發、自己驗收上線還是挺爽滴。這其中工作簡單的就是自動化運維
。但我今天真正要講的不是做了什麽，或者用了
...[详细]
                    
                
                                
                    為什麽說WEB框架PasteApeart是AI Coding時代的黃金搭檔
	
，從此開啟敏捷開發新思路
                    
                        
                        在AI代碼生成工具大行其道的今天
，一個大膽的論斷正在開發者社區流傳：有一個WEB框架，其開發效率可以超越AI。這聽起來像是天方夜譚，但PasteApeart即升級版PasteForm）正將這一設想變為
...[详细]
                    
                
                                
                    感謝艾思科藍成為博客園讚助商
                    
                        
                        在2025年歲末臨近之際
，園子又添驚喜	，迎來一家新的讚助商——艾思科藍。非常感謝艾思科藍的讚助！以下是艾思科藍的介紹：艾思科藍(AiScholar)，立足科研領域的連接者	，致力於探索“人工智能+科研學
...[详细]
                    
                
                                
                    代碼是 AI 寫的，生產事故誰背鍋	？
                    
                        
                        最近在做 Code Review 的時候	，我發現團隊裏越來越多的年輕工程師	，開始頻繁提交一些看起來極其規整、甚至連注釋都寫得完美無缺，但稍微往深了一看，業務邏輯根本跑不通的代碼
。問他們怎麽寫的	，答案出
...[详细]
                    
                
                                
                    實戰對比
：用 mpremote/Putty/MobaXterm 連接樹莓派 Pico REPL，誰更省心	？
                    
                        
                        電腦連接樹莓派 Pico通過 USB 連接我們可以利用多個遠程控製終端通過 USB 線和樹莓派 Pico 進行連接通信	，常見的遠程控製終端包括 MobaXterm
、Putty、mpremote
、Xsh
...[详细]
                    
                
                            
        
        
        
        	热点阅读
            
            	                骑行恢复期完整指南
                                CJ2027 展会内容
                                按摩设备选购完整指南
                                按摩特殊场景完整指南
                                完整版电视剧短剧
                                写真布光用光完整
                                素人实体概念整理
                                写真图片完整整理
                                素人词义解释
                                52按摩实用指南与设备参考
                            
        
        
        	随机内容
            
                                訂單的含金量在分化

                                C# .NET 周刊 ｜2026 年 8 月 2 期

                                
            
            
            	                AI 寫代碼有多厲害？——快了 55%，但錯多了 75%
                                MicroPython 開發避坑
：用 Signal 類解決不同電路的電平兼容問題
                                AI 編碼 Agent 從原理到可運行代碼
                                MHS 三部曲（上）：別急著叫它「物理 MCP」——Anthropic 到底發布了什麽
                                別再吹牛了，100% Vibe Coding 存在無法自洽的邏輯漏洞

！
                                k8s安裝metrics
                                為什麽說WEB框架PasteApeart是AI Coding時代的黃金搭檔
，從此開啟敏捷開發新思路

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

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

把 `Where`和 `Select`融合起來

值類型特化版字符串：`ValueString`

布爾結構

整體流程：編譯並執行查詢

把字符串塞進類型

字麵量工廠

把執行計劃塞進類型係統

結果轉換

編譯 `SELECT`

null 字符串字麵量

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

尾聲

過濾器

`SELECT col`/ `SELECT col1, col2, ...`

實現一個 SQL 子集

比較表達式

數值字麵量

前言

`SELECT *`

搭好整個管道類型

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

`使用和性能測試`

`快速上手`

簡單性能對比

編譯 `WHERE`

列和投影

友情链接

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

ValueTupleConvertHelper：用動態 IL 在元組之間搬運字段

把 Where和 Select融合起來

值類型特化版字符串 ：ValueString

布爾結構

整體流程：編譯並執行查詢

把字符串塞進類型

字麵量工廠

把執行計劃塞進類型係統

結果轉換

編譯 SELECT

null 字符串字麵量

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

尾聲

過濾器

SELECT col/ SELECT col1, col2, ...

實現一個 SQL 子集

比較表達式

數值字麵量

前言

SELECT *

搭好整個管道類型

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

使用和性能測試

快速上手

簡單性能對比

編譯 WHERE

列和投影

友情链接

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

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

把 `Where`和 `Select`融合起來

值類型特化版字符串：`ValueString`

整體流程：編譯並執行查詢

編譯 `SELECT`

`SELECT col`/ `SELECT col1, col2, ...`

`SELECT *`

`使用和性能測試`

`快速上手`

編譯 `WHERE`