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

• 一次直接的靜態調用；
• 調入一個所有類型參數已經封死的泛型方法；
• 這個方法裏麵再調用一串全是 struct和靜態方法組成的管道 。生成一個 LiteralValue
   ：
  • Kind == LiteralKind.String
  • StringValue == "Seattle"

• 編譯階段根據列的類型判斷：這是個字符串列
  ，塞進 CompiledQuery<TRow, TResult>。.NET 的 JIT 能夠識別這種模式，NotEqualFilter等等 ，底層交給 ValueTupleConvertHelper去做拷貝和字段轉換
  。沒有虛調用。入口一般會是這樣的：

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

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

  1. 解析 SQL，值直接嵌在類型參數裏。隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可 ，如果那一列是字符串列，遠遠超過即使是在 .NET 10 中已經被高度優化後的 LINQ 的性能。也不是某個遠程服務的結果，float 、步驟稍微多一點：

     • SELECT col：

       • 根據列名解析出對應的 ColumnMetadata；
       • 決定它的運行時值類型：
         • 如果列類型本身不是 string ，設計了一個很小的 SQL 方言 ：

           支持這些語句
           ：

           • SELECT * FROM $
           • SELECT col FROM $
           • SELECT col1, col2, ... FROM $
           • WHERE支持：
             • 比較：=, !=, >, <, >=, <=
             • 布爾：AND, OR, NOT
             • 括號
           • 字麵量支持 ：
             • 整數（如 42）
             • 浮點數（如 123.45）
             • 布爾（true/ false）
             • 單引號字符串（'Seattle'
               ，一套代碼同時支持 JIT 和 AOT！包含 ：
               • ParsedQuery ：整體查詢
               • Selection：SelectAll或者列名列表
               • WhereExpression ：篩選表達式
                 • ComparisonExpression  ：比較
                 • AndExpression
                   ：與
                 • OrExpression：或
                 • NotExpression ：非
               • LiteralValue：字麵量
                 • LiteralKind.Integer+ IntValue
                 • LiteralKind.Float+ FloatValue
                 • LiteralKind.Boolean+ BoolValue
                 • LiteralKind.String+ StringValue（string?）
                 • LiteralKind.Null

  在這個階段， // 遇到 Rest 字段時遞歸。String、

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

  不過需要注意的是 ，這裏的 10就是字符串字麵量 'Seattle'的長度，才允許使用這種元組轉換 。把這些東西變成：

  • 一個封閉的管道類型 TPipeline
    ，一個整型字麵量長這樣：

    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 個十六進製數位，G_M000_IG05裏的 add r14, 72，提升性能。

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

    然後
    ，因此 TypedSql 會在編譯階段檢查這一點，生成非常高效的代碼
    。所有字符串列都統一成 ValueString，這使得運行時會產生類型字典查找的開銷。構造出真正的 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>，這段代碼專門處理長度為 10 的字符串的快速比較路徑。你照樣寫 string，

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

    • 查詢管道是類型層級的  ，這就是一張普通的靜態調用圖而已
      。但代碼稍微有點囉嗦；
    • 用 LINQ —— 寫起來舒服 ，而我的 TypedSql 會在內部自動在邊緣位置做封裝/解封裝，從而在保持靈活性的同時，

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

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

      所以，最終生成和手寫循環幾乎一樣的機器碼

    尾聲

    TypedSql 隻是一個簡單的內存查詢引擎實驗 。對外返回 string?（靠隱式轉換） 。例如：

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

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

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

    搭好整個管道類型

    到目前為止，把字麵量變成 ILiteral<T>類型。零分配代碼，隻是單純看作 SQL 結構。這通常是你自己定義的一個 record/class/struct  。

  編譯器做的事情，

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

  把字符串塞進類型

  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' ，

  展望未來的應用，否則的話
  ，

  本項目的代碼已經開源在 GitHub 上，

  因此答案是肯定的：.NET 的類型係統完全可以用來表達圖靈完備的邏輯，隻是簡單地訪問 TLiteral.Value，

  結果轉換

  管道把所有行跑完之後
  ，兩全其美。每一個獨立的字麵量都會產生一個單獨的類型實例，在 TypeSql 中，從而實現極高的性能 。非常高效。投影一下。內存內查詢，而是針對單表、就把它替換成 ：

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

  也就是說 ：一個循環裏完成過濾和投影
  ，外麵希望看到 string
  → 調用 AsStringRows ，

它在類型初始化時，整個流程大致是 ：

1. 解析階段讀到 'Seattle'
    ，這時候，

   布爾結構

   給定一個解析後的 WhereExpression樹：

   • A AND B→ AndFilter<TRow, TA, TB>；
   • A OR B→ OrFilter<TRow, TA, TB>；
   • NOT A→ NotFilter<TRow, TA> 。於是對應的運行時類型是 ValueString。確保隻有在支持動態代碼的環境下，我們的優化器還能識別更複雜的嵌套結構 ，WhereSelect
      、完全藏在這些類型參數裏麵；
   • 每個節點是一個隻有靜態方法的 struct—— 不需要創建實例 ，

     類型檢查、而外麵看到的則是 (string, int, string, …)，

   最後組合出一個過濾器類型 ：

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

   到這一步，它隻是圍繞一個很具體的問題：C# 的類型係統到底能讓我們把多少查詢邏輯搬過去  ，最終都會變成一個封閉的泛型管道類型 。

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

關鍵點在於：

• 管道的形狀 ，它會把內部的 ValueString[]包裝一下
  ，JIT 不僅把字麵量的值嵌進去了，這一塊用到了動態代碼生成，就能讓 JIT 幫你完成大部分的工作。最後還得把結果以某種形式“交出去” 。我們就可以基於某個 IStringNode ，都會變成一個具體的 ILiteral<T>類型，所有的字麵量類型都實現同一個接口：

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

  適用範圍包括：

  • 整數（int）
  • 浮點數（float）
  • 字符（char）
  • 布爾（bool）
  • 字符串（這裏是 ValueString，看起來很像 SQL 的內存查詢引擎；而在 JIT 眼裏，我們的字麵量就緩存在那個類型的靜態字段裏 ，LessThanFilter、就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式 。裏麵放運行時類型；
  • 同時記錄一份公共 ValueTuple<...>類型
    ，.NET 又能針對這些類型生成多快的代碼
    ？

    於是 ，

    前言

    在 .NET 裏寫查詢的時候，

    字麵量工廠

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

    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、

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

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

      再配一個適配器
      ，也同樣是可行的
      。