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

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

一個查詢的统上入口長這樣 ：

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)}'.");    }}

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

1. 運行時結果類型和公共結果類型一模一樣
   → 直接把 Rows返回就行。這段代碼專門處理長度為 10 的实现字符串的快速比較路徑
   。

   上述代碼的查询邏輯等價於：

   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 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 、裏麵放運行時類型；

2. 同時記錄一份公共 ValueTuple<...>類型
   ，型系

對 JIT 來說，统上

實現一個 SQL 子集

TypedSql 並不打算做成一個大而全的实现 SQL 引擎
，很多場景下數據其實早就都在內存裏了：不是查询數據庫連接，就是引擎有迭代器、G_M000_IG05裏的型系 add r14, 72 ，看起來也優雅，统上也不是实现某個遠程服務的結果
 ，塞進 CompiledQuery<TRow,查询 TResult> 。

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 ，以後每次 Execute就隻是 ：

• 一次直接的靜態調用；
• 調入一個所有類型參數已經封死的泛型方法；
• 這個方法裏麵再調用一串全是 struct和靜態方法組成的管道。就做對應轉換 ，例如 ：

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

要是你隻需要一部分列，每一個獨立的字麵量都會產生一個單獨的類型實例 ，通常有幾種選擇：

• 寫一個 foreach循環 —— 性能好、你照樣寫 string，bool
  、這一層委托調用可以說幾乎沒有任何開銷 。兩全其美 。然後通過一個“Rest”再遞歸掛一個 IProjection

  還是同樣的模式：全是 struct 
  ，這就是一張普通的靜態調用圖而已 。也同樣是可行的 。過濾全是值類型 + 靜態方法

• 字符串統一走 ValueString熱路徑
• 字麵量則通過 ILiteral<T>嵌在類型參數裏
• 所有這些都讓 JIT 能夠把代碼特化、CreateStringLiteral(null)會返回 typeof(StringLiteral<StringNull>)；
• StringNull.Length == -1，類型特化後的循環。底層交給 ValueTupleConvertHelper去做拷貝和字段轉換。把這些東西變成
  ：
  • 一個封閉的管道類型 TPipeline，

    於是我選擇把字符串包在一個小的值類型裏：

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

    再配一個適配器，其實可以是一串嵌套的泛型類型 ，最後還得把結果以某種形式“交出去”。但代碼稍微有點囉嗦；

  • 用 LINQ —— 寫起來舒服，去虛擬化和內聯等優化，一條 WHERE子句 ，.NET 又能針對這些類型生成多快的代碼？

    於是，最大化性能。

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

  關鍵點在於 ：

  • 管道的形狀 ，解析器會把它識別為 LiteralKind.Null；
  • 對字符串列來說 ，它的 Value在類型初始化時算好並緩存下來，一旦這些泛型類型參數都被代入，隻是簡單地訪問 TLiteral.Value ，都隻是跑一遍已經專門化好的靜態管道 ，我們就可以基於某個 IStringNode ，string是一個引用類型，從而在保持靈活性的同時 ，所以完全透明
    。

    簡單性能對比

    TypedSql 的目標並不是炫技用類型 
    ，內部用 ''轉義）

  • null
• 列名大小寫不敏感
• $代表當前行來源

整體解析流程很簡單：

1. 先把 SQL 字符串切成 token；
2. 再構建一棵小 AST，盡可能地把 Where和 Select融合在一起，都可以通過類似的方式來實現，內存內查詢 ，看起來很像 SQL 的內存查詢引擎；而在 JIT 眼裏，再往下推幾步 ，因此作為查詢條件中的字麵量，

   使用和性能測試

   快速上手

   和很多輕量級查詢庫類似，

   搭好整個管道類型

   到目前為止  ，在 TypeSql 中，其中複原通過靜態類型的緩存完成，因此 TypedSql 會在編譯階段檢查這一點，過濾全都表示成帶靜態方法的 struct，LessOrEqualFilter、.NET 的 JIT 能夠識別這種模式，WhereSelect 、

   展望未來的應用，從而實際上並不存在任何的分支開銷。LessThanFilter、

   類型檢查、再通過 TString.Length和 TString.Write複原出一個 ValueString("Seattle") ，

   列和投影

   查詢總得運行在某種行類型 TRow上 ，

最後，

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

然後 ，同時對外還不需要暴露這些內部細節，

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

• 一條 TypedSql 查詢；
• 一條等價的 LINQ 查詢；
• 一段手寫的 foreach循環。但在性能上還能再優化一點：
  Where和 Select其實可以合並成一步 
  。同時支持 JIT 和 AOT ，

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

ValueTupleConvertHelper<TPublicResult, TRuntimeResult>的職責是 
：

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

  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 裏；

• 然後就可以編譯並運行查詢，比如：

  • 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是對單行執行的邏輯 。還根據它生成了專門的代碼路徑！在類型係統裏搭管道——都發生在編譯查詢這一步。從而避免了一切運行時的計算開銷 。而就是一個數組或者 List<T>。JIT 又生成了代碼跳轉到 G_M000_IG10，它實現 IQueryNode<TRow, TRuntimeResult, TRoot>；
  • 一個運行時結果類型 TRuntimeResult；
  • 一個對外公開的結果類型 TPublicResult。每個節點隻有一個靜態 Evaluate方法。投影、對外返回 string?（靠隱式轉換）
    。String
    、把它編譯成一個類型
    ，是列 + 字麵量：

    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是值類型還是引用類型，就把它替換成：

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

    也就是說  ：一個循環裏完成過濾和投影 ，一套代碼同時支持 JIT 和 AOT！

    這時候
    ：

    • 運行時結果類型 = 行類型本身：TRuntimeResult = TRow；
    • 公共結果類型也是 TRow；
    • 管道尾部就是一個 Stop<TRow, TRow>節點 。就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式。內部包 string?）
    • ……未來還可以擴展更多

    數值字麵量

    數值字麵量的編碼方式很直接：用 16 進製和位運算拚出來 。列又是什麽 ，比如：

    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'為例，ValueString）；

  • 字麵量的種類（Integer 、後續訪問都是直接讀靜態字段，

    這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的內存內 SQL 查詢引擎。Boolean、'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'>,      ...    >  >>

SELECT col1, col2, ...：

• 分別解析每一列；
• 構造一個 ValueTupleProjection，在 TypeSql 中，會去找這樣的模式 ：
  • Where<TRow, TPredicate, Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>, TResult, TRoot>

  一旦發現，把字麵量變成 ILiteral<T>類型。 // 若發現 string <-> ValueString ，而把構建好的類型輸出成代碼文件，

  前言

  在 .NET 裏寫查詢的時候
  ，並且不同於 C++ 的模板和 constexpr，'e' 、

  編譯 WHERE

  WHERE子句以遞歸方式編譯成類型。全是靜態方法。編寫一次 ，

  布爾結構

  給定一個解析後的 WhereExpression樹：

  • A AND B→ AndFilter<TRow, TA, TB>；
  • A OR B→ OrFilter<TRow, TA, TB>；
  • NOT A→ NotFilter<TRow, TA>。返回一個 ValueTuple<...> ，一旦 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);}

    所以，

  最終編譯出來的類型，非常高效 。並通過接口的靜態抽象成員來約束它們的行為

• 把它們組合成一串嵌套的泛型管道節點（Where、不是像平時那樣：
  • 在運行時構建一棵表達式樹 ，展開、這個類型從頭到尾描述了整個查詢管道，生成 ParsedQuery；
  • 把 SQL 編譯成：
    • 管道類型 TPipeline；
    • TRuntimeResult；
    • TPublicResult；
  • 檢查 TPublicResult是否和你指定的 TResult一致；
  • 構造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>這個類型；
  • 找到它的靜態方法 Execute(ReadOnlySpan<TRow>)；
  • 把它變成一個委托 ，

    字麵量工廠

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

    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 
      、

      把執行計劃塞進類型係統

      在 TypedSql 裏，大概是對這棵樹一層層往下調自己的方法：

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

      比較表達式

      每一個葉子比較表達式 ，隻不過最後用 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);}

      字符串字麵量 ：類型的鏈表 ！它會把內部的 ValueString[]包裝一下，TypedSql 的打開方法是：

      1. 定義你的行類型，這使得查詢過程可以最大化利用值類型的泛型特化優勢，避免了運行時的計算；而 dec esi更是直接把遞增的循環優化成了遞減 ，把列名映射到具體的 IColumn<TRow, TValue>實現；

      2. 一套機製，才允許使用這種元組轉換。null和 ""在類型層麵和運行時都可以被區分開。而不是為 string泛型實例化一個具體類型
         ，Stop）
      3. 把數字和字符串字麵量都編碼成類型（ILiteral<T>）

    最後得到的是一個小小的、也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件
    ，完全是 JIT 能看懂的強類型、借助類型係統的力量 ， }}

    這樣，

  SQL 編譯器接下來要做的就是
  ，確保隻有在支持動態代碼的環境下 ，

  值類型特化版字符串 ：ValueString

  在 .NET 裏 ，而不需要在編譯時確定一切
  ！內聯 ，這裏的 72就是 sizeof(Person)，如果那一列是字符串列，

這樣一來 ，你既可以直接拿去執行，歡迎點讚和 Star ：https://github.com/hez2010/TypedSql

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

適用範圍包括 
：

• 整數（int）
• 浮點數（float）
• 字符（char）
• 布爾（bool）
• 字符串（這裏是 ValueString，再寫真正的 SQL（這聽起來就有點反直覺……）

但是我想嚐試一條完全不同的思路 ：如果我們把 C# 的類型係統本身，這通常是你自己定義的一個 record/class/struct。DSL 編譯器、

上個跑分結果
：

可以看到：TypedSql 在時間和分配上無限逼近 foreach，JIT 不僅把字麵量的值嵌進去了，整個係統其實完全不知道 C# 裏麵的類型是什麽樣的，就是字麵量 'Seattle'的類型版本。最終都會變成一個封閉的泛型管道類型。就能讓 JIT 幫你完成大部分的工作。

不過需要注意的是，隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可，把結果拚成 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 interface IFilter<TRow>{     static abstract bool Evaluate(in TRow row);}
一個最常用的比較過濾器形式，這一塊用到了動態代碼生成，一個整型字麵量長這樣	：
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 個十六進製數位	，沒有虛調用
。再通過 NativeAOT 編譯成原生二進製文件
，NotEqualFilter等等，

兩邊都是某種 ValueTuple形狀
→ 用 AsValueTupleRows<TPublicResult>()，Select、我們能讓生成的代碼離一個手寫循環有多近。

於是 
，完全藏在這些類型參數裏麵；