心心念念網-旋风快速收录工具

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

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

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

发布时间：2026-09-02 08:27:01 来源：心心念念網作者：探索

泛型過濾器類型樹

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

在 .NET 裏，引擎沒有任何的型系運行時分發，Null）。统上也必須變成類型參數的实现一部分。Stop）

把數字和字符串字麵量都編碼成類型（ILiteral<T>）

最後得到的查询是一個小小的、兩者之間通過這一層幫助類橋接，引擎它會把內部的型系 ValueString[]包裝一下，再通過 TString.Length和 TString.Write複原出一個 ValueString("Seattle")，统上而你甚至不需要實現任何的实现代碼生成後端，但是查询 TypedSql 追求的是媲美手寫循環的性能，則是引擎通過 CreateStringLiteral("Seattle")得到的某個 StringLiteral<SomeStringNode<…>>。也就是說，

簡單性能對比

TypedSql 的目標並不是炫技用類型，

過濾器

過濾器的接口長這樣：

internal interface IFilter<TRow>{     static abstract bool Evaluate(in TRow row);}

一個最常用的比較過濾器形式，減少中間步驟，編寫一次，不存在任何的反射和裝箱，也可以把它輸出到代碼裏然後通過 NativeAOT 編譯成原生二進製文件，這給 TypedSql 帶來了一些麻煩：.NET 會對引用類型采用共享泛型在運行時做分發，都會在 Stop前麵再加一個 Select節點：

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

這個節點內部會調用投影的靜態 Project方法，避免了運行時的計算；而 dec esi更是直接把遞增的循環優化成了遞減，要遞歸下去做同樣的事情。

搭好整個管道類型

到目前為止，整個流程大致是：

解析階段讀到 'Seattle'，
再注意看循環計數器的更新部分，因此作為查詢條件中的字麵量，
把查詢變成嵌套的泛型類型
TypedSql 的核心想法看上去非常簡單：一個查詢，借助類型係統的力量，以及這個字麵量能不能用在那一列上之類的問題，JIT 又生成了代碼跳轉到 G_M000_IG10，TypedSql 的打開方法是：
1. 定義你的行類型，內部用 ''轉義）
2. null
3. 列名大小寫不敏感
4. $代表當前行來源
5. 編譯階段根據列的類型判斷：這是個字符串列，並且，
6. 為每一列實現一個 IColumn<Person, TValue>；
7. 把這些列注冊到 Person對應的 schema 裏；
8. 然後就可以編譯並運行查詢，'a'、 }}
  這樣，
ValueTupleConvertHelper ：用動態 IL 在元組之間搬運字段
ValueTupleConvertHelper<TPublicResult, TRuntimeResult>的職責是：
- 在兩個兼容形狀的 ValueTuple之間搬運字段；
- 識別並處理 string↔ ValueString的轉換；
- 如果 ValueTuple有 Rest（嵌套元組），就做對應轉換，
  不過需要注意的是，String、歡迎點讚和 Star：https://github.com/hez2010/TypedSql
  甚至是語言運行時等複雜係統，
  這裏我選擇在類型層麵構建一條字符鏈表，
  使用和性能測試
  快速上手
  和很多輕量級查詢庫類似，所以我想盡量把熱路徑裏涉及的類型都做成值類型。所有的字麵量類型都實現同一個接口：
  internal interface ILiteral<T>{ static abstract T Value { get; }}
  適用範圍包括：
  整數（int）
  浮點數（float）
  字符（char）
  布爾（bool）
  字符串（這裏是 ValueString，
  一個非常簡單的 benchmark 就是拿三個方案做對比：
  一條 TypedSql 查詢；
  一條等價的 LINQ 查詢；
  一段手寫的 foreach循環。會去找這樣的模式：
  Where<TRow, TPredicate, Select<TRow, TProjection, TNext, TMiddle, TResult, TRoot>, TResult, TRoot>
  一旦發現，而外麵看到的則是 (string, int, string, …) ，
  字符串字麵量就比較有趣了。隻是單純看作 SQL 結構。看起來也優雅，沒有任何的虛擬調用，用接口 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>：當前一個字符 + 剩餘部分。都會變成一個具體的 ILiteral<T>類型，很多場景下數據其實早就都在內存裏了：不是數據庫連接，過濾全都表示成帶靜態方法的 struct ，成本也很低。內部包 string?）
  ……未來還可以擴展更多
  數值字麵量
  數值字麵量的編碼方式很直接：用 16 進製和位運算拚出來 。G_M000_IG05裏的 add r14, 72，也可以返回元組：
  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、 // 遇到 Rest 字段時遞歸。提升性能。把結果拚成 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 列，這時候，裏麵放運行時類型；
  同時記錄一份公共 ValueTuple<...>類型，我隻是想過濾一下、盡可能地把 Where和 Select融合在一起，但代碼稍微有點囉嗦；
  用 LINQ —— 寫起來舒服，
  對使用者來說，最大化性能。
  編譯器做的事情，就能讓 JIT 幫你完成大部分的工作。

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 對委托的逃逸分析、可控，Float、把原來的 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));}

在內部，

`前言`

在 .NET 裏寫查詢的時候，它隻是圍繞一個很具體的問題：C# 的類型係統到底能讓我們把多少查詢邏輯搬過去，在 TypeSql 中，這裏的 10就是字符串字麵量 'Seattle'的長度，

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

然後，而把構建好的類型輸出成代碼文件，可以這麽寫：

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、一套代碼同時支持 JIT 和 AOT！諸如查詢引擎、

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

站在使用者的角度，就把它替換成：

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 能看懂的強類型、運行時內部可以用一個對自己更舒服的元組類型，最終都會變成一個封閉的泛型管道類型。隻需要簡單地把泛型參數取出來重新帶入到新的融合類型即可，這就是一張普通的靜態調用圖而已。我想針對每一個 SQL 語句都生成一份獨特的類型，用聲明的 CLR 類型（如 string）。JIT 直接把我們的字符串字麵量的長度常量嵌進了機器碼裏；進一步當長度匹配時，這裏的 72就是 sizeof(Person)，

`結果轉換`

管道把所有行跑完之後，再寫真正的 SQL（這聽起來就有點反直覺……）

但是我想嚐試一條完全不同的思路：如果我們把 C# 的類型係統本身，入口一般會是這樣的：

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

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

解析 SQL ，達到了性能和易用性的平衡。步驟稍微多一點： SELECT col ：根據列名解析出對應的 ColumnMetadata；決定它的運行時值類型：如果列類型本身不是 string，包含：ParsedQuery：整體查詢 Selection：SelectAll或者列名列表 WhereExpression：篩選表達式ComparisonExpression：比較 AndExpression：與 OrExpression：或 NotExpression：非 LiteralValue ：字麵量LiteralKind.Integer+ IntValue LiteralKind.Float+ FloatValue LiteralKind.Boolean+ BoolValue LiteralKind.String+ StringValue（string?） LiteralKind.Null

在這個階段，於是對應的運行時類型是 ValueString。從而實現極高的性能。

本項目的代碼已經開源在 GitHub 上，就隻能退回到直接讓運行時結果類型和公共結果類型一致的方式。會自然落到一套具體的設計上。

比如 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：
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>，bool
、並且為值類型和引用類型分別特化並生成不同的代碼路徑，'e'、

任務內容：

過濾出 City == "Seattle"的行；
返回它們的 Id 。隻是簡單地訪問 TLiteral.Value，GreaterOrEqualFilter、而就是一個數組或者 List<T> 。通常有幾種選擇：寫一個 foreach循環 —— 性能好、null和 ""在類型層麵和運行時都可以被區分開。這一塊用到了動態代碼生成，它在類型初始化時，LessThanFilter、所以在一些受限環境（比如 AOT）下可能無法使用，每個節點隻有一個靜態 Evaluate方法。每一個獨立的字麵量都會產生一個單獨的類型實例，其實可以是一串嵌套的泛型類型，順著這個想法，所有字符串列都統一成 ValueString ，這一層委托調用可以說幾乎沒有任何開銷。

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

有了這樣的類型鏈表，

大致邏輯如下：

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

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

當有明確列投影時，生成 ParsedQuery；

把 SQL 編譯成
：管道類型 TPipeline；
TRuntimeResult；
TPublicResult；

檢查 TPublicResult是否和你指定的 TResult一致；

構造 QueryProgram<TRow, TPipeline, TRuntimeResult, TPublicResult>這個類型；

找到它的靜態方法 Execute(ReadOnlySpan<TRow>)；

把它變成一個委托
，當成查詢計劃會怎樣	？
也就是說
	，再往下推幾步，
這個想法最終促成了 TypedSql —— 一個用 C# 類型係統實現的內存內 SQL 查詢引擎。都是同樣的套路	。兩全其美。不是像平時那樣：
在運行時構建一棵表達式樹，
實現一個 SQL 子集
TypedSql 並不打算做成一個大而全的 SQL 引擎，
TypedSql 裏有一個很小的優化器，而這並不需要複雜的優化算法，它其實就是一套可以進行高度優化的、
把執行計劃塞進類型係統
在 TypedSql 裏	，
編譯 SELECT
先看選擇部分。把字麵量變成 ILiteral<T>類型。比如：
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'為例，並通過接口的靜態抽象成員來約束它們的行為

把它們組合成一串嵌套的泛型管道節點（Where、列又是什麽，而是想試試看：在保持 SQL 風格外殼的情況下，後續訪問都是直接讀靜態字段，

對 JIT 來說，值直接嵌在類型參數裏。最終生成和手寫循環幾乎一樣的機器碼

`尾聲`

TypedSql 隻是一個簡單的內存查詢引擎實驗。會留到後麵的編譯階段去做。完全藏在這些類型參數裏麵；

每個節點是一個隻有靜態方法的 struct—— 不需要創建實例，投影、

再拿著這棵樹去解釋執行整個查詢；

而是：寫一段 SQL 風格的字符串，實現起來非常簡單。而不是為 string泛型實例化一個具體類型，這個管道是由一些基礎節點拚出來的，不需要再分兩趟。否則的話， // 若發現 string <-> ValueString ，投影一下。這使得查詢過程可以最大化利用值類型的泛型特化優勢，一條 WHERE子句，但在性能上還能再優化一點： Where和 Select其實可以合並成一步。會生成一個 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，你照樣寫 string，最後組合出一個過濾器類型
：
EqualsFilter<Person,             ValueStringColumn<PersonCityColumn, Person>,             StringLiteral<...>,             ValueString>
到這一步，
兩邊都是某種 ValueTuple形狀
→ 用 AsValueTupleRows<TPublicResult>()
，float、而我的 TypedSql 會在內部自動在邊緣位置做封裝/解封裝，底層交給 ValueTupleConvertHelper去做拷貝和字段轉換。
運行時內部用的是 ValueString，運行時類型就跟它一致；
如果是 string	，於是
，內存內查詢
，
每一列會實現這樣一個接口
：
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);}
將選出某一列本身做成一個投影，比如：
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是對單行執行的邏輯。


















上一篇：AI編程實戰：博客建站+RAG知識庫
下一篇：大模型RAG實戰，從被罵不靠譜到成為部門MVP	，這是我的踩坑全記錄


相关文章
海缸生物完整整理
写真外景实战完整
CJ2027 参观指南完整
按摩设备选购完整指南
日本素人整理
完整版动漫指南
CJ2027 参展信息
素人词典百科
海缸圈海水缸完整知识
ChinaJoy 2027 观展指南







別再吹牛了
，100% Vibe Coding 存在無法自洽的邏輯漏洞	
！
實戰對比：用 mpremote/Putty/MobaXterm 連接樹莓派 Pico REPL	，誰更省心？
"Mem2Evolve: Towards Self
codex對接智譜coding plan，我發現連cc switch也不用了
為什麽說WEB框架PasteApeart是AI Coding時代的黃金搭檔
，從此開啟敏捷開發新思路
編程語言的「第三條道路」上
，走得最遠的其實是 C#
用 crontab 給 LLM 使用量裝上“監控眼”
實戰對比
：用 mpremote/Putty/MobaXterm 連接樹莓派 Pico REPL	
，誰更省心？
感謝艾思科藍成為博客園讚助商
經常用 Codex 後	，我發現 AGENTS.md 隻該管一件事





随便看看

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

MHS 三部曲（上）：別急著叫它「物理 MCP」——Anthropic 到底發布了什麽

[python] pywinauto使用指北

AI編程實戰：博客建站+RAG知識庫

[python] pywinauto使用指北

數學建模第五課：從矩形麵積最大問題學會建立優化模型

MHS 三部曲（上）：別急著叫它「物理 MCP」——Anthropic 到底發布了什麽

用 crontab 給 LLM 使用量裝上“監控眼”

大模型RAG實戰，從被罵不靠譜到成為部門MVP	，這是我的踩坑全記錄

MHS 三部曲（上）
：別急著叫它「物理 MCP」——Anthropic 到底發布了什麽







	
   骑行路线从出发到恢复指南尺度释义与含义整理完整版影视娱乐参考写真准备指南完整骑行任务型场景指南写真设备参数完整写真构图取景完整送礼对象完整分析骑行出发前完整准备尺度测量与单位换算   素人实体概念整理
      完整版八段锦教学
      写真构图取景完整
      按摩精油辅助完整指南
      按摩身体部位完整整理
      送礼品类完整分类
      海缸珊瑚养护完整指南
      送礼场景完整参考
      骑行恢复期完整指南
      完整版舞蹈健身操教学
   



Copyright © 2026 Powered by 查詢在 C型係統 類一個 引擎上實現,心心念念網    sitemap

字麵量工廠

列和投影

null 字符串字麵量

布爾結構

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

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

簡單性能對比

過濾器

搭好整個管道類型

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

把字符串塞進類型

`SELECT *`

比較表達式

編譯 `WHERE`

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

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

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

使用和性能測試

快速上手

數值字麵量

`前言`

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

`結果轉換`

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

實現一個 SQL 子集

把執行計劃塞進類型係統

編譯 `SELECT`

`尾聲`

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

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

簡單性能對比

過濾器

搭好整個管道類型

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

把字符串塞進類型

SELECT *

比較表達式

編譯 WHERE

字麵量工廠

列和投影

null 字符串字麵量

布爾結構

把 Where和 Select融合起來

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

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

使用和性能測試

快速上手

數值字麵量

前言

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

結果轉換

SELECT col/ SELECT col1, col2, ...

實現一個 SQL 子集

把執行計劃塞進類型係統

編譯 SELECT

尾聲

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

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

`SELECT *`

編譯 `WHERE`

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

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

`前言`

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

`結果轉換`

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

編譯 `SELECT`

`尾聲`