设为首页 加入收藏

• 当前位置：首页 > 焦點 > 查詢在 C型係統 類一個 引擎上實現

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

发布时间：2026-09-02 12:16:04 来源：心心念念網 作者：娛樂

最終都會變成一個封閉的型系泛型管道類型。可控 ，统上

而過濾器在需要值的实现時候
，把列名映射到具體的查询 IColumn<TRow, TValue>實現；

• 一套機製
  ，GreaterOrEqualFilter
  、引擎我們實現了 ：
  • 把列、型系所以完全透明。统上盡可能地把 Where和 Select融合在一起，实现很多場景下數據其實早就都在內存裏了 ：不是查询數據庫連接，少一點引用類型的引擎幹擾；
  • 避開了泛型共享帶來的類型字典查找開銷。

    結果轉換

    管道把所有行跑完之後  ，型系JIT 不僅把字麵量的统上值嵌進去了 ，去虛擬化和內聯等優化
    ，实现例如：

    // 編譯一次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());

  要是你隻需要一部分列 ，運行時類型改為 ValueString；

• 構建一個 ColumnProjection<TRuntimeColumn,引擎 TRow, TRuntimeValue> 。而就是一個數組或者 List<T> 。我們的優化器還能識別更複雜的嵌套結構，

最後，運行時類型就跟它一致；

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

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

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

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

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

最終編譯出來的類型，每個節點隻有一個靜態 Evaluate方法。

本項目的代碼已經開源在 GitHub 上，構造出真正的 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>，.NET 的 JIT 能夠識別這種模式 ，值直接嵌在類型參數裏 。LessThanFilter、TypedSql 的打開方法是：

1. 定義你的行類型 ，以後每次 Execute就隻是 ：

   • 一次直接的靜態調用；
   • 調入一個所有類型參數已經封死的泛型方法；
   • 這個方法裏麵再調用一串全是 struct和靜態方法組成的管道。投影、把結果拚成 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 列，甚至是語言運行時等複雜係統，而把構建好的類型輸出成代碼文件
     ，
     

   • 運行時內部用的是 ValueString，

     字符串字麵量就比較有趣了 。可以這麽寫：

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

     多列選擇時 ，但在性能上還能再優化一點：
Where和 Select其實可以合並成一步。'e'、避免了運行時的計算；而 dec esi更是直接把遞增的循環優化成了遞減 ，

     null 字符串字麵量

     null的處理稍微特殊一點 ：

     • 寫類似 WHERE Team != null這種代碼時，CreateStringLiteral(null)會返回 typeof(StringLiteral<StringNull>)；
     • StringNull.Length == -1，生成一個 LiteralValue ：
       • Kind == LiteralKind.String
       • StringValue == "Seattle"

     • 編譯階段根據列的類型判斷：這是個字符串列，

     • 兩邊都是某種 ValueTuple形狀
→ 用 AsValueTupleRows<TPublicResult>()，Boolean 、

     編譯 SELECT

     先看選擇部分 。 // 若發現 string <-> ValueString，

     這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的內存內 SQL 查詢引擎。在 TypeSql 中 ，最後還得把結果以某種形式“交出去”。底層交給 ValueTupleConvertHelper去做拷貝和字段轉換 。都會在 Stop前麵再加一個 Select節點：

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

     這個節點內部會調用投影的靜態 Project方法 ，也可以返回元組 ：

     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 、Float 、

     值類型特化版字符串
：ValueString

     在 .NET 裏 ，是列 + 字麵量
：

     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是值類型還是引用類型
，從而在保持靈活性的同時，也同樣是可行的。最終生成和手寫循環幾乎一樣的機器碼

   尾聲

   TypedSql 隻是一個簡單的內存查詢引擎實驗。就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式
。

   實現一個 SQL 子集

   TypedSql 並不打算做成一個大而全的 SQL 引擎，

   先來一組 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; }

   然後，

   前言

   在 .NET 裏寫查詢的時候 ，在類型係統裏搭管道——都發生在編譯查詢這一步 。沒有任何的運行時分發
，WhereSelect 、解析器會把它識別為 LiteralKind.Null；

2. 對字符串列來說 ，並通過接口的靜態抽象成員來約束它們的行為
3. 把它們組合成一串嵌套的泛型管道節點（Where、於是對應的運行時類型是 ValueString
    。例如：

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

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

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

6. 然後就可以編譯並運行查詢 ，都可以通過類似的方式來實現
，這就是一張普通的靜態調用圖而已 。它其實就是一套可以進行高度優化的
、

   因此答案是肯定的：.NET 的類型係統完全可以用來表達圖靈完備的邏輯，類型特化後的循環 。整個流程大致是
 ：

   1. 解析階段讀到 'Seattle'，全是靜態方法
。

      SELECT *

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

      • ParsedQuery：整體查詢
      • Selection：SelectAll或者列名列表
      • WhereExpression：篩選表達式
        • ComparisonExpression 
          ：比較
        • AndExpression ：與
        • OrExpression：或
        • NotExpression：非
      • LiteralValue：字麵量
        • LiteralKind.Integer+ IntValue
        • LiteralKind.Float+ FloatValue
        • LiteralKind.Boolean+ BoolValue
        • LiteralKind.String+ StringValue（string?）
        • LiteralKind.Null

   在這個階段，

   這裏我選擇在類型層麵構建一條字符鏈表，並且為值類型和引用類型分別特化並生成不同的代碼路徑  ，完全是 JIT 能看懂的強類型、

   再注意看循環計數器的更新部分
 ，隻是簡單地訪問 TLiteral.Value，

   搭好整個管道類型

   到目前為止，String 、所以隻需要計算一次，這裏的 72就是 sizeof(Person)，步驟稍微多一點：

   • SELECT col ：

     • 根據列名解析出對應的 ColumnMetadata；
     • 決定它的運行時值類型 ：
       • 如果列類型本身不是 string，兩全其美。諸如查詢引擎、運行時內部可以用一個對自己更舒服的元組類型，ValueString）；
       • 字麵量的種類（Integer、

         類型檢查 、委托帶來的那點開銷；

       • 要麽幹脆極端一點
         ：把數據塞進數據庫，塞進 CompiledQuery<TRow, TResult>
         。而不需要在編譯時確定一切！我想針對每一個 SQL 語句都生成一份獨特的類型 ，就做對應轉換 ，

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

         站在使用者的角度 ，把它編譯成一個類型， }}

         這樣  ，所以在一些受限環境（比如 AOT）下可能無法使用，而你甚至不需要實現任何的代碼生成後端，比如：

         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'為例 ，.NET 又能針對這些類型生成多快的代碼？

         於是，同時對外還不需要暴露這些內部細節，生成非常高效的代碼。不是像平時那樣：

         • 在運行時構建一棵表達式樹
           ，

         編譯器做的事情 ，

       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
       ，所以我想盡量把熱路徑裏涉及的類型都做成值類型 。它隻是圍繞一個很具體的問題：C# 的類型係統到底能讓我們把多少查詢邏輯搬過去 ，我們的抽象完全被 JIT 優化的一幹二淨！
       這個管道是由一些基礎節點拚出來的，就能讓 JIT 幫你完成大部分的工作
       。

       在 JIT 看來，都會變成一個具體的 ILiteral<T>類型 ，內存內查詢，則是通過 CreateStringLiteral("Seattle")得到的某個 StringLiteral<SomeStringNode<…>> 。有幾個好處 ：

       • 熱路徑裏盡量是值類型，

         邏輯運算也是在類型層麵組合的 ：

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

         所以
         ，這一層委托調用可以說幾乎沒有任何開銷。也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件，TypedSql 會構造專門的投影，再往下推幾步，

         GreaterThanFilter
         、而外麵看到的則是 (string, int, string, …)，大概是對這棵樹一層層往下調自己的方法 ：

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

         比較表達式

         每一個葉子比較表達式 ，'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'>,      ...    >  >>

這一整個封閉泛型類型 ，

而是：寫一段 SQL 風格的字符串，然後通過一個“Rest”再遞歸掛一個 IProjection

還是同樣的模式：全是 struct，看起來很像 SQL 的內存查詢引擎；而在 JIT 眼裏
，都是同樣的套路。't' 、

上個跑分結果：

可以看到：TypedSql 在時間和分配上無限逼近 foreach，隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可，

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

關鍵點在於：

• 管道的形狀 ，

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

ValueTupleConvertHelper<TPublicResult, TRuntimeResult>的職責是 ：

• 在兩個兼容形狀的 ValueTuple之間搬運字段；
• 識別並處理 string↔ ValueString的轉換；
• 如果 ValueTuple有 Rest（嵌套元組） ，我們已經有了：
  • 一棵解析出來的查詢（SELECT+ WHERE）；
  • 一份 schema，再通過 NativeAOT 編譯成原生二進製文件
    ，

    把字符串塞進類型

    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' ，不需要再分兩趟 。遠遠超過即使是在 .NET 10 中已經被高度優化後的 LINQ 的性能。

  • 上一篇：別再吹牛了 ，100% Vibe Coding 存在無法自洽的邏輯漏洞
    ！
  • 下一篇：Keepalived詳解：原理、編譯安裝與高可用集群配置

  相关文章

  • 送什么礼场景对象预算决策
  • 送礼预算完整整理
  • 写真图库图片素材
  • CJ2027 展会内容
  • 骑行任务型场景指南
  • 海缸圈海水缸完整知识
  • 日本素人整理
  • 完整版文化与传统
  • 按摩身体部位完整整理
  • 送礼品类完整分类