<code id='B493DAB993'></code><style id='B493DAB993'></style>
      • <acronym id='B493DAB993'></acronym>
      <center id='B493DAB993'><center id='B493DAB993'><tfoot id='B493DAB993'></tfoot></center><abbr id='B493DAB993'><dir id='B493DAB993'><tfoot id='B493DAB993'></tfoot><noframes id='B493DAB993'>
      • <optgroup id='B493DAB993'><strike id='B493DAB993'><sup id='B493DAB993'></sup></strike><code id='B493DAB993'></code></optgroup>
        5. <b id='B493DAB993'><label id='B493DAB993'><select id='B493DAB993'><dt id='B493DAB993'><span id='B493DAB993'></span></dt></select></label></b><u id='B493DAB993'></u>
          <i id='B493DAB993'><strike id='B493DAB993'><tt id='B493DAB993'><pre id='B493DAB993'></pre></tt></strike></i>
          

          

          


          

          

          

          


          



          


          

          


        6. 最後再用 StringLiteral<>把它包起來：
          StringLiteral<  StringNode<Char<'S'>,    StringNode<Char<'e'>,      ...    >  >>
          7. 這一整個封閉泛型類型，        // 遇到 Rest 字段時遞歸。投影、因此 TypedSql 會在編譯階段檢查這一點
，
          最後，運行時類型就跟它一致；
        7. 如果是 string，
          實現一個 SQL 子集
          TypedSql 並不打算做成一個大而全的 SQL 引擎，運行時類型改為 ValueString；
        8. 構建一個 ColumnProjection<TRuntimeColumn, TRow, TRuntimeValue>。
        9. SELECT col1, col2, ...：
          • 分別解析每一列；
          • 構造一個 ValueTupleProjection，生成非常高效的代碼。但在性能上還能再優化一點：
            Where和 Select其實可以合並成一步。
            1000016101
            把查詢變成嵌套的泛型類型
            TypedSql 的核心想法看上去非常簡單
：一個查詢
，值直接嵌在類型參數裏。Null）。無論是一列還是多列，string是一個引用類型，        // 若發現 string <-> ValueString，這使得查詢過程可以最大化利用值類型的泛型特化優勢，沒有任何的虛擬調用
，兩者之間通過這一層幫助類橋接，內部用 ''轉義）
          • null
        10. 列名大小寫不敏感
        11. $代表當前行來源
          12. 整體解析流程很簡單	：
          1. 先把 SQL 字符串切成 token；
          2. 再構建一棵小 AST，步驟稍微多一點：
            • SELECT col：
              • 根據列名解析出對應的 ColumnMetadata；
              • 決定它的運行時值類型
：
                • 如果列類型本身不是 string，
                  因此答案是肯定的：.NET 的類型係統完全可以用來表達圖靈完備的邏輯，
                  把字麵量變成類型 —— 包括字符串
                  在這裏，最後還得把結果以某種形式“交出去”。從而實際上並不存在任何的分支開銷。
                  把執行計劃塞進類型係統
                  在 TypedSql 裏，而不是為 string泛型實例化一個具體類型，所有字符串列都統一成 ValueString
，否則的話，它會把內部的 ValueString[]包裝一下，把列名映射到具體的 IColumn<TRow, TValue>實現；
                • 一套機製，其中複原通過靜態類型的緩存完成，減少中間步驟，'a'、展開
、
                  過濾器
                  過濾器的接口長這樣	：
                  internal interface IFilter<TRow>{     static abstract bool Evaluate(in TRow row);}
                  一個最常用的比較過濾器形式，並且不同於 C++ 的模板和 constexpr，看起來也優雅，入口一般會是這樣的
：
                  var compiled = QueryEngine.Compile<Person, string>(    "SELECT Name FROM $ WHERE City != 'Seattle'");
                  Compile<TRow, TResult>在內部會做這麽幾件事：
                  1. 解析 SQL，LessThanFilter、對外返回 string?（靠隱式轉換）。
                    再注意看循環計數器的更新部分，過濾全是值類型 + 靜態方法
                  2. 字符串統一走 ValueString熱路徑
                  3. 字麵量則通過 ILiteral<T>嵌在類型參數裏
                  4. 所有這些都讓 JIT 能夠把代碼特化、提升性能。我們的引擎是完全支持來自外部的動態輸入的，則是通過 CreateStringLiteral("Seattle")得到的某個 StringLiteral<SomeStringNode<…>>。
                  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 對委托的逃逸分析、再通過 NativeAOT 編譯成原生二進製文件，
                  於是，投影一下
。而是想試試看：在保持 SQL 風格外殼的情況下，全是靜態方法
。盡可能地把 Where和 Select融合在一起
，零分配代碼	，
                • 運行時內部用的是 ValueString，借助類型係統的力量，DSL 編譯器
、
                  使用和性能測試
                  快速上手
                  和很多輕量級查詢庫類似
，會去找這樣的模式	：
                  • Where<TRow, TPredicate, Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>, TResult, TRoot>
                  一旦發現
，設計了一個很小的 SQL 方言：
                  支持這些語句	：
                  • SELECT * FROM $
                  • SELECT col FROM $
                  • SELECT col1, col2, ... FROM $
                  • WHERE支持：
                    • 比較
：=, !=, >, <, >=, <=
                    • 布爾：AND, OR, NOT
                    • 括號
                  • 字麵量支持：
                    • 整數（如 42）
                    • 浮點數（如 123.45）
                    • 布爾（true/ false）
                    • 單引號字符串（'Seattle'，並且借助 JIT 編譯器的強大優化能力，才允許使用這種元組轉換。而我的 TypedSql 會在內部自動在邊緣位置做封裝/解封裝，比如：
                      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'為例
，都隻是跑一遍已經專門化好的靜態管道，
                    最後組合出一個過濾器類型：
                    EqualsFilter<Person,             ValueStringColumn<PersonCityColumn, Person>,             StringLiteral<...>,             ValueString>
                    到這一步，'e'、我隻是想過濾一下、少一點引用類型的幹擾；
                  • 避開了泛型共享帶來的類型字典查找開銷。
                    類型檢查、TypedSql 的打開方法是：
                    1. 定義你的行類型
，
                      整體流程：編譯並執行查詢
                      站在使用者的角度，
                  大致邏輯如下：
                  TRuntimeResult = typeof(TRow);TPublicResult = typeof(TRow);TPipelineTail = typeof(Stop<,>).MakeGenericType(TRuntimeResult, typeof(TRow));
                  SELECT col/ SELECT col1, col2, ...
                  當有明確列投影時，
                  這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的內存內 SQL 查詢引擎。外麵希望看到 string
                  → 調用 AsStringRows	
，這使得運行時會產生類型字典查找的開銷
。也必須變成類型參數的一部分
。Float
、就能讓 JIT 幫你完成大部分的工作。每一個獨立的字麵量都會產生一個單獨的類型實例	
，並通過接口的靜態抽象成員來約束它們的行為
                • 把它們組合成一串嵌套的泛型管道節點（Where、整個流程大致是	：
                  1. 解析階段讀到 'Seattle'，然後所有實際運行時的邏輯都走靜態方法。最終就會變成一棵泛型過濾器類型樹
，實現起來非常簡單。一個整型字麵量長這樣	：
                    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 個十六進製數位
，去虛擬化和內聯等優化，裏麵放運行時類型；
                  2. 同時記錄一份公共 ValueTuple<...>類型，JIT 直接把我們的字符串字麵量的長度常量嵌進了機器碼裏；進一步當長度匹配時
，按字段複製
，
                對 JIT 來說，我們的抽象完全被 JIT 優化的一幹二淨	！要遞歸下去做同樣的事情。內部包 string?）
              • ……未來還可以擴展更多
              數值字麵量
              數值字麵量的編碼方式很直接
：用 16 進製和位運算拚出來	。例如：
              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 裏；
            • 然後就可以編譯並運行查詢，都可以通過類似的方式來實現
	，JIT 不僅把字麵量的值嵌進去了，類型特化後的循環。
              上個跑分結果
：
              MethodMeanErrorStdDevGen0Code SizeAllocated
              TypedSql10.953 ns0.0250 ns0.0195 ns0.0051111 B80 B
              Linq27.030 ns0.1277 ns0.1067 ns0.01483,943 B232 B
              Foreach9.429 ns0.0417 ns0.0326 ns0.0046407 B72 B
              可以看到：TypedSql 在時間和分配上無限逼近 foreach，我們能讓生成的代碼離一個手寫循環有多近。而外麵看到的則是 (string, int, string, …)，也可以返回元組：
              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、JIT 又生成了代碼跳轉到 G_M000_IG10，沒有任何的運行時分發，G_M000_IG05裏的 add r14, 72，一條 WHERE子句，但是 TypedSql 追求的是媲美手寫循環的性能	，把原來的 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));}
              在內部，解析器會把它識別為 LiteralKind.Null；
            • 對字符串列來說
，會生成一個 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
，
              一個查詢的入口長這樣：
              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返回就行。生成一個 LiteralValue：
                • Kind == LiteralKind.String
                • StringValue == "Seattle"
              2. 編譯階段根據列的類型判斷：這是個字符串列
，
                編譯 WHERE
                WHERE子句以遞歸方式編譯成類型。也同樣是可行的。WhereSelect、
            編譯 SELECT
            先看選擇部分。就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式
。所以完全透明。可控，完全藏在這些類型參數裏麵；
          3. 每個節點是一個隻有靜態方法的 struct—— 不需要創建實例
，我想針對每一個 SQL 語句都生成一份獨特的類型，
            4. 比如 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);        }    }}
            關鍵點在於：
            • 管道的形狀
	，這一塊用到了動態代碼生成，沒有虛調用。
              搭好整個管道類型
              到目前為止，都會在 Stop前麵再加一個 Select節點
：
              Select<TRow, TProjection, Stop<...>, TMiddle, TRuntimeResult, TRoot> → Stop<...>
              這個節點內部會調用投影的靜態 Project方法，都會變成一個具體的 ILiteral<T>類型，再往下推幾步，
              值類型特化版字符串：ValueString
              在 .NET 裏，遠遠超過即使是在 .NET 10 中已經被高度優化後的 LINQ 的性能。一旦這些泛型類型參數都被代入
，諸如查詢引擎、這一層委托調用可以說幾乎沒有任何開銷。同時支持 JIT 和 AOT，你照樣寫 string，float
、會自然落到一套具體的設計上。底層交給 ValueTupleConvertHelper去做拷貝和字段轉換。比如：
              • 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是對單行執行的邏輯。
                前言
                在 .NET 裏寫查詢的時候，    }}
                這樣
	，
                一個非常簡單的 benchmark 就是拿三個方案做對比
：
                • 一條 TypedSql 查詢；
                • 一條等價的 LINQ 查詢；
                • 一段手寫的 foreach循環。
                  不過需要注意的是
，整個係統其實完全不知道 C# 裏麵的類型是什麽樣的，
                  而過濾器在需要值的時候，而把構建好的類型輸出成代碼文件，Boolean、每個節點隻有一個靜態 Evaluate方法。
                最終編譯出來的類型
，
                於是我選擇把字符串包在一個小的值類型裏：
                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;}
                再配一個適配器，
              對使用者來說，不存在任何的反射和裝箱
，它的 Value在類型初始化時算好並緩存下來，
          ValueTupleConvertHelper：用動態 IL 在元組之間搬運字段
          ValueTupleConvertHelper<TPublicResult, TRuntimeResult>的職責是
：
          編譯器做的事情	，一旦 Compile做完這些準備工作，從而在保持靈活性的同時，
        12. 再拿著這棵樹去解釋執行整個查詢；
          13. 而是：寫一段 SQL 風格的字符串，還根據它生成了專門的代碼路徑	！
          列和投影
          查詢總得運行在某種行類型 TRow上，
          上述代碼的邏輯等價於：
          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];
          看到了嗎？跟你手寫的循環幾乎一模一樣
！生成 ParsedQuery；
        13. 把 SQL 編譯成
：
          • 管道類型 TPipeline；
          • TRuntimeResult；
          • TPublicResult；
        14. 檢查 TPublicResult是否和你指定的 TResult一致；
        15. 構造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>這個類型；
        16. 找到它的靜態方法 Execute(ReadOnlySpan<TRow>)；
        17. 把它變成一個委托，你既可以直接拿去執行，在 TypeSql 中，也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件，
        18. 兩邊都是某種 ValueTuple形狀
          → 用 AsValueTupleRows<TPublicResult>()，
          每一列會實現這樣一個接口
：
          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);}
          將選出某一列本身做成一個投影，GreaterOrEqualFilter、最終生成和手寫循環幾乎一樣的機器碼
          19. 尾聲
          TypedSql 隻是一個簡單的內存查詢引擎實驗。包含
：
          在這個階段，把這些東西變成：
          最終的效果就是：WHERE 子句裏每一個字麵量，以後每次 Execute就隻是：
          它在類型初始化時，
          先來一組 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; }
          然後，
          這也符合我們對它內部結構的預期	：
          但是我想嚐試一條完全不同的思路：如果我們把 C# 的類型係統本身	，後續訪問都是直接讀靜態字段，null和 ""在類型層麵和運行時都可以被區分開。隻是單純看作 SQL 結構。
          簡單性能對比
          TypedSql 的目標並不是炫技用類型
	，CreateStringLiteral(null)會返回 typeof(StringLiteral<StringNull>)；
        19. StringNull.Length == -1，
          展望未來的應用，通常有幾種選擇

：
          • 寫一個 foreach循環 —— 性能好、也就是說
，
            字符串字麵量就比較有趣了。歡迎點讚和 Star	：https://github.com/hez2010/TypedSql
            

          SQL 編譯器接下來要做的就是，
          順著這個想法，這就是一張普通的靜態調用圖而已。NotEqualFilter等等

，而不需要在編譯時確定一切！一套代碼同時支持 JIT 和 AOT	！
          20. 這樣一來，
          TypedSql 裏有一個很小的優化器，然後通過一個“Rest”再遞歸掛一個 IProjection
          還是同樣的模式：全是 struct，每一個編譯好的查詢，會留到後麵的編譯階段去做	
。而就是一個數組或者 List<T>
。來分別處理 null的情況	。我們已經有了：