diff --git a/.workbuddy/memory/2026-09-05.md b/.workbuddy/memory/2026-09-05.md new file mode 100644 index 00000000..217a6675 --- /dev/null +++ b/.workbuddy/memory/2026-09-05.md @@ -0,0 +1,26 @@ +# 2026-09-05 + +## 通读 LightORM 项目并生成技术大纲 + +产出 `doc/项目大纲.md`(约 11 章 + 2 个附录),覆盖双主线架构、方言层、执行层、源生成器、AOT 设施、缺口清单与阅读路线。 + +### 项目核心认知 + +- **双主线**:A 表达式→SQL(IExpSelect → SelectProvider → SelectBuilder → ExpressionResolver → ISqlMethodResolver → IDatabaseAdapter);B DbDataReader→对象(SqlAdo → InternalDataReader → ExpressionBuilder.BuildDeserializer → Expression.Compile())。两线在 `Extension/SelectResultExtensions.cs` 的 InternalToList 汇合。 +- **三层职责分离**:解析器管片段生成 / Builder 管结构组装 / Adapter 管方言翻译。 +- **易混命名**:`src/LightORM/Providers/` 是核心库内 SQL 生成 Provider;`src/Providers/` 才是独立数据库方言 NuGet 包。 + +### 实测发现的坑(后续可做) + +- `LightOrmTableContextGenerator/TableContextGenerator.CreateDeserializeMethod.cs`:生成的方法体是 `throw new NotImplementedException()`,完整实现整体注释掉了 → **AOT 静态反序列化路径当前不可用**,实际仍全部走 `ExpressionBuilder` 动态编译。 +- `Cache/DeserializerCache.cs`:空壳,直接 throw NotImplementedException。 +- `Utils/ExpressionAotHelper.cs`:空桩。 +- `SqlExecutor/OrignalSqlExecutor.cs`:标记 `[Obsolete]` 但仍是主实现。 +- `AssemblyInfo.cs`:`ShowSqlExecutorDebugInfo` / `ShowExpressionHashCodeDebugInfo` 默认 true。 +- `IsAOTRuntime` = `!RuntimeFeature.IsDynamicCodeSupported && AOTSupported`,`AOTSupported` 由 `ExpressionSqlBuilder.cs:74` 置 true。 + +### 有用的速查 + +- 表达式缓存:FNV-1a 64 位(`Utils/Vistors/ExpressionHasher.cs`),参数名与常量值默认不参与哈希,`NeedToExtractValues` 触发 `ExpressionValueExtract` 每次重新取值 —— 结构解析一次 / 值提取每次。 +- 反序列化:缓存键 = `类型 FullName + 每列「列名:DataType:AllowDBNull」`;四路类型分派 = 元组 / 基础类型 / 匿名(Expression.New)/ 具名(MemberInit);每成员三段 = 取值 GetXxx(i) + 转换 + `IsDBNull ? default : value` 三元。 +- 新增数据库方言 = 实现 5 个类:Custom{DB}Adapter / {DB}MethodResolver / {DB}Provider / {DB}TableHandler / {DB}TableOptions。 diff --git "a/doc/\347\211\210\346\234\254\346\227\245\345\277\227.md" "b/doc/\347\211\210\346\234\254\346\227\245\345\277\227.md" index fd9a110f..de22f199 100644 --- "a/doc/\347\211\210\346\234\254\346\227\245\345\277\227.md" +++ "b/doc/\347\211\210\346\234\254\346\227\245\345\277\227.md" @@ -1,6 +1,15 @@ # 版本功能更新记录 -## 2026.09.02 +## v2026.09.05 +- 🐞现在ScopedContext在释放前,不归还Connection对象 +- 🐞表达式解析缓存键新增层级 +- 🐞解析结果需要处理Template时,使用with {}复制对象,避免污染缓存 +- 🐞修复子查询的层级错误 +- ⚡️新增GroupBy方言处理(MySql 8.0以下版本不支持 CUBE, GROUPING SETS) +- 🐞修复SqlServer的分页查询的ORDER BY子语句 +- 🐞修复FlatGrouping中的KeySelector的参数替换 + +## v2026.09.02 - 🐞`WhereIf(bool condition, Expression> exp)`处理TypeSet类型 - ⚡️`IScopedExpressionContext`释放时,自动提交事务 diff --git "a/doc/\351\241\271\347\233\256\345\244\247\347\272\262.md" "b/doc/\351\241\271\347\233\256\345\244\247\347\272\262.md" new file mode 100644 index 00000000..520730d6 --- /dev/null +++ "b/doc/\351\241\271\347\233\256\345\244\247\347\272\262.md" @@ -0,0 +1,701 @@ +# LightORM 项目大纲 + +> 基于 `F:\GitRepositories\LightORM` 全量源码通读整理(2026-09-05) +> 核心库 `MT.LightORM` 约 200 个源文件 / 23,000 行,不含 obj/bin + +--- + +## 0. 一句话定位 + +**LightORM = 表达式树 → SQL 的翻译器 + DbDataReader → 对象的反序列化器。** + +它刻意不做变更追踪、不做一级缓存、不做复杂状态管理,只把两件事做到极致: + +| 主线 | 输入 | 输出 | +| ------------ | -------------------------------------- | ------------------------------------- | +| **A. 表达式翻译** | `Expression>` 等 LINQ 表达式 | SQL 字符串 + `DbParameter` 集合 | +| **B. 读取序列化** | `DbDataReader` | `Func` 委托(动态编译 / 源生成) | + +三条设计铁律贯穿全项目: + +1. **零依赖** —— 核心库只用 `System.Linq.Expressions` + `System.Data.Common` +2. **三层职责分离** —— 解析器管"片段生成"、Builder 管"结构组装"、Adapter 管"方言翻译" +3. **源生成器替代反射** —— 用 Roslyn 生成器把实体元数据静态化,为 AOT 让路 + +--- + +## 1. 项目全景 + +### 1.1 解决方案地图 + +``` +LightORM.slnx +├── src/ +│ ├── LightORM/ # 核心库(Assembly: MT.LightORM)★ +│ ├── LightOrmExtensionGenerator/ # 源生成器①:多泛型 Select 重载 +│ ├── LightOrmTableContextGenerator/ # 源生成器②:实体表上下文 + AOT 反序列化 +│ ├── GenShared/Generators.Shared/ # 两个生成器共享的代码生成 DSL(.shproj) +│ ├── LightORM.Extensions.DependencyInjection/ # DI 扩展包 +│ └── Providers/ # 7 个数据库方言包 +│ ├── Sqlite / MySql / SqlServer / Oracle / PostgreSQL +│ └── Dameng(达梦)/ KingbaseES(人大金仓) ← 国产库 +├── test/ # 11 个工程:LightORMTest(.Sqlite/.MySql/.Oracle/.PostgreSQL/.SqlServer/.Dameng) +│ # BenchmarkTest / PerformanceTest / SqlGenerateTest / TestWeb / TestProject1 +├── DatabaseUtils/ # 独立的数据库管理工具项目 +└── doc/ # 版本日志.md +``` + +### 1.2 包与目标框架 + +| 项 | 值 | +| ------- | --------------------------------------------------- | +| 核心库 TFM | `net462` / `netstandard2.0` / `net8.0` / `net10.0` | +| AOT | `IsAotCompatible = true`,全链路裁剪标注 | +| 生成器打包 | 针对 `netstandard2.0`,进 NuGet 的 `analyzers/dotnet/cs` | +| 许可证 | MIT | + +### 1.3 核心库目录职责 + +| 目录 | 职责 | +| ---------------- | ------------------------------------------------------------------------------- | +| `Interfaces/` | 全部对外契约,含 `ExpSql/` 流式查询接口子树 | +| `ExpressionSql/` | 上下文引擎:`ExpressionCoreSql`、作用域、事务、多库切换 | +| `Providers/` | **核心库内的** SQL 片段生成 Provider(Select/Insert/Update/Delete/Group/Include) | +| `Builder/` | SQL 结构组装器:`SelectBuilder` / `InsertBuilder` / `UpdateBuilder` / `DeleteBuilder` | +| `Utils/` | 表达式解析器、值提取器、SQL 函数桩、各类 ExpressionVisitor | +| `SqlExecutor/` | 执行层:`SqlAdo`、`ExpressionBuilder`(反序列化委托生成)、`InternalDataReader` | +| `Implements/` | Provider/Adapter/MethodResolver 基类 | +| `Cache/` | `TableContext`、参数读取器、列比较器 | +| `Performances/` | 连接池 + 5 类对象池 + `SlimList` | +| `Attributes/` | `LightColumn` / `LightFlat` / `LightNavigate` / `LightJsonMap` / `LightTable` 等 | +| `Repository/` | 仓储 + `IQueryable` 支持 | +| `DbStruct/` | 表结构模型与"实体→DDL" | +| `Models/` | 上下文模型:`TableInfo` / `ColumnInfo` / `JoinInfo` / `TypeSet` 等 | + +> ⚠️ 命名易混点:`src/LightORM/Providers/` 是**核心库内的 SQL 生成 Provider**;`src/Providers/` 是**独立的数据库方言 NuGet 包**。两者完全不同。 + +--- + + +## 2. 双主线架构总览 + +``` + 用户代码 + │ + ┌──────────────┴──────────────┐ + ▼ ▼ +【主线 A】写方向 【主线 B】读方向 +Expression → SQL DbDataReader → 对象 + │ │ + IExpressionContext SqlAdo.ExecuteReader + │ │ + IExpSelect InternalDataReader + │ (流式 API) │ + SelectProvider0/1/2..16 ExpressionBuilder.BuildDeserializer + │ (门面) │ ┌──────────────┬──────────────┐ + SelectBuilder ▼ ▼ ▼ + │ (片段容器) 运行时路径 AOT 路径 + ExpressionResolver Expression.Compile 源生成器产出静态方法 + │ (递归翻译) (缓存委托) (ITableEntityInfo + ISqlMethodResolver .DataReaderDeserializer) + │ (方法→SQL函数) + IDatabaseAdapter + │ (方言) + SQL + DbParameters +``` + +两线在 `SelectResultExtensions.InternalToList` 处汇合:先 `ToSqlString()` 出 SQL 与参数 → `SqlAdo` 执行得 `DbDataReader` → `BuildDeserializer` 得到映射委托 → 逐行 `des(reader)` 产出对象。 + +--- + +## 3. 主线 A:表达式 → SQL + +### 3.1 一条完整数据流 + +``` +Expression> + │ + ▼ ExpressionResolver.Visit() Utils/ExpressionResolver.cs + │ switch 分派 11 种节点,边遍历边往 StringBuilder 追加片段 + ▼ ResolveContext Utils/ResolveContext.cs + │ 维护「参数表达式 → TableInfo(别名/索引)」映射,parent 链支持子查询回溯外层列 + ▼ ISqlMethodResolver Implements/BaseSqlMethodResolver.cs + │ C# 方法调用 → SQL 函数 / 语法 + ▼ SelectBuilder.HandleResult() Builder/SelectBuilder.cs + │ 按 SqlPartial 把片段分派到 Where/Join/Select/GroupBy/OrderBy/Having 容器 + ▼ SelectBuilder.Build() + │ 按固定顺序递归组装;子查询/CTE/Join子查询/Union 递归,level 控制缩进与别名层级 + ▼ IDatabaseAdapter + │ 标识符引用符、分页、布尔/日期字面量、JSON 函数 + ▼ +SQL 字符串 + DbParameters +``` + +### 3.2 入口层:`IExpressionContext` 家族 + +``` +IContext(Select/Insert/Update/Delete/QueryMultiple + Ado) + └── IExpressionContext ← 默认多库上下文,ExpressionCoreSql + │ SwitchDatabase(key) → ITransientContext (TransientContext) + │ CreateScoped(key) → ISingleScopedExpressionContext (SingleScopedExpressionCoreSql) + └ CreateScoped() → IScopedExpressionContext (ScopedExpressionCoreSql,支持跨库事务) +``` + +切换的本质是更换底层 `SqlAdo` 绑定的 `DatabaseConnection`;三者共享同一套 `Select/Insert/Update/Delete` 入口(实现集中在 `ExpressionSql/ExpressionCoreSqlContextMethodImpl.cs`)。 + +### 3.3 流式接口体系 + +| 接口 | 文件 | 承载 | +| ------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------------------------- | +| `ISql` | `Interfaces/ExpSql/ISql.cs` | 标记接口,暴露 `DbContext/Executor/SqlBuilder/IsSubQuery` | +| `IExpSelect0` | `IExpSelect0.cs` | 与表数无关的能力:`Where/WhereIf/ToList/First/Count/Max/Min/Sum/Avg/Any/Distinct/AsTemp` | +| `IExpSelect` | `IExpSelect`1.cs\` | 加 `Join*/OrderBy*/GroupBy/Include/Union/WithTempQuery` | +| `IExpSelect` | `IExpSelect`2.cs\` | 双表 Join/Where/OrderBy + `TypeSet` 扁平投影 | +| `IExpSelect` | **源生成器产出** | 每 Join/WithTemp 一张表升一阶泛型 | +| `IExpSelectGroup` | `IExpSelectGroup.cs` | 分组后上下文,暴露 `IExpSelectGrouping` 聚合/窗口函数 | +| `IExpTemp` | `IExpTemp.cs` | CTE 临时表 | +| `IExpInsert` / `IExpUpdate` / `IExpDelete` / `IExpInclude` | 同名文件 | 写操作与导航加载 | + +**为什么需要 16 个泛型版本?** LightORM 用泛型参数个数编码"当前已 Join/WithTemp 的表元组",让 `Where/OrderBy/Select` 的 lambda 能对全部已参与表做强类型访问。`InnerJoin` 返回 `SelectProvider{n+1}`,每加一表升一阶,16 是工程上限。这些重载全部由 `LightOrmExtensionGenerator` 机械展开生成,避免手写数百个近乎相同的类。 + + +### 3.4 Provider 门面层(`src/LightORM/Providers/`) + +Provider 是**门面 + Builder 持有者**,把流式调用翻译成对 Builder 片段容器的写入;Builder 在 Join 后通过 `new SelectProviderN(同一 builder)` 在多个 Provider 间传递,实现链式状态共享。 + +| Provider | 文件 | 对应 Builder | +| ------------------------------------- | ------------------------------------------ | ---------------------------------- | +| `SelectProvider0/1/2` | `Providers/Select/*.cs` | `SelectBuilder` | +| `SelectProvider3..16` | 源生成器产出 | 同上 | +| `SelectInsertProvider` | `Providers/Select/SelectInsertProvider.cs` | `InsertBuilder`(INSERT ... SELECT) | +| `GroupSelectProvider` | `Providers/GroupSelectProvider.cs` | `SelectBuilder` + 聚合展平 | +| `IncludeProvider` | `Providers/IncludeProvider.cs` | `SelectBuilder.Includes` | +| `TempProvider` | `Providers/Select/TempProvider.cs` | `SelectBuilder`(IsTemp) | +| `InsertProvider` | `Providers/InsertProvider.cs` | `InsertBuilder` | +| `UpdateProvider` | `Providers/UpdateProvider.cs` | `UpdateBuilder` | +| `DeleteProvider` | `Providers/DeleteProvider.cs` | `DeleteBuilder` | + +典型落点:`Where(exp)` → `SelectHandleExtensions.WhereHandle` → `SqlBuilder.Expressions.Add(new ExpressionInfo(SqlResolveOptions.Where, exp))`。 + + +### 3.5 Builder 组装层(`src/LightORM/Builder/`) + +`SqlBuilder`(抽象基类)持有 `Expressions`、`ResolveCtx`、`DbParameters` 与 `ResolveExpressions()`;`SelectBuilder` 继承它并维护片段容器: + +| 容器 | 内容 | +| ------------------------------------------------ | ------------------------------ | +| `SelectValue` | SELECT 投影(默认 `*`) | +| `Where: List` | 最终用 `AND` 连接 | +| `joins: List` | 每个 JoinInfo 自带 `Where` | +| `GroupBy` / `GroupingSets` | 分组 + ROLLUP/CUBE/GROUPING SETS | +| `OrderBy: List` / `Having: List` | 排序与分组过滤 | +| `IsDistinct` / `Skip` / `Take` | 去重与分页 | +| `Unions: List` | UNION / UNION ALL | +| `TempViews: List` | CTE | +| `SubQuery` / `IsTemp` / `TempName` | 子查询与临时表 | +| `Includes: SortedSet` | 导航属性加载 | + +**四个关键方法** + +- `ResolveExpressions(database)` —— 遍历 `Expressions`,每条调 `exp.Expression.Resolve(options, ctx)`,结果交给 `HandleResult` 按 `SqlPartial` 路由;完成后置 `IsCompleted` 防重复解析 +- `HandleResult` —— `switch(SqlPartial)` 分发;遇导航属性触发 `ScanNavigate` +- `Build(StringBuilder, database, level)` —— 按 `WITH → SELECT [DISTINCT] → FROM → JOIN → WHERE → GROUP BY → HAVING → ORDER BY → Paging → UNION` 顺序递归拼装 +- `EstimateSqlLength()` —— 先预估容量再向 `StringBuilderPool` 租预分配的 StringBuilder,避免扩容拷贝 + +`SqlPartial` 枚举值:`None, Select, SelectFunc, Insert, Update, UpdateVersionColumn, Delete, UpdatePartial, Ignore, Join, Where, GroupBy, OrderBy, Having`。 + +**`ScanNavigate`(导航属性自动 JOIN)**:检测到 `UseNavigate` 后递归展开——一对多经中间表需 **2 次 JOIN**,一对一 **1 次**,嵌套导航递归下降(`NavigateDeep` 递减)。 + + +### 3.6 表达式翻译层(核心引擎) + +#### `ExpressionResolver`(`Utils/ExpressionResolver.cs`,674 行) + +`Visit` 用 switch 模式匹配分派 11 种节点: + +| 节点 | 翻译 | +| ----------------------- | ------------------------------------------------------------------- | +| `LambdaExpression` | 登记参数 → `Context.HandleParameterExpression` | +| `BinaryExpression` | 左右递归 + `OperatorParser` 运算符;Where/Join/Select 语境自动加括号 | +| `ConditionalExpression` | `CASE WHEN ... THEN ... ELSE ... END` | +| `MethodCallExpression` | 委托 `ISqlMethodResolver`;`get_Item` 走索引器语义 | +| `NewArrayExpression` | `IN (...)` 列表 | +| `NewExpression` | SELECT 投影 + `AS` 别名 | +| `UnaryExpression` | `Not` → 置 `IsNot` 标志位;`Convert` → 置 `IsVisitConvert` | +| `ParameterExpression` | 表别名;Select 语境展开为 `alias.*`;Insert 语境展开全部列 | +| `MemberInitExpression` | 投影绑定 + 别名 | +| `MemberExpression` | **列名**(`Expression` 是 Parameter)vs **值**(`Expression` 是闭包 Constant) | +| `ConstantExpression` | 字面量 / 参数占位符 | + +**精妙细节** + +- **索引器双重语义**:`int` 索引 → JSON 数组 `[3]`;`string` 索引 → JSON 对象 `["prop"]` +- **`IsNot` 标志位**:`Not` 节点置位,后续 `Contains`/`In` 消费它生成 `NOT LIKE` / `NOT IN` +- **列名 vs 值判定**:`MemberExpression.Expression` 是 `ParameterExpression` → 列;是 `ConstantExpression` → 闭包变量值 +- **null 处理**:`Equal` + null → `IS NULL`;值侧生成 8 位随机占位名,延后到 `ReplaceConstantValue` 统一替换 + +#### `ResolveContext`(`Utils/ResolveContext.cs`) + +解析期上下文枢纽: + +- `parent` 链 + `Depth = parent.Depth + 1` —— 子查询引用外层列时 `GetTable` 沿链向上回溯 +- `lambdaParameterInfos: Dictionary` —— 参数 → 表/别名/索引 +- `ParameterPrefix` —— 逐层加 `_` 后缀,隔离同名参数 +- `HandleParameterExpression` / `GetTable` / `SetParamPrefix` + +#### `ISqlMethodResolver`(`Implements/BaseSqlMethodResolver.cs`,719 行) + +用 `Dictionary` 注册方法名 → 翻译动作。 + +**基类直接实现**:`Format / Result / Exits / In / Count / CountDistinct / Sum / Average / Max / Min / Abs / Round / Nvl / IsNull / Coalesce / Grouping / Trim* / Join / Distinct / Separator / Where / WhereIf / Any / RowNumber / Lag / Rank / PartitionBy / OrderBy* / Value / Case / When / Then / Else / End` + +**强制 Provider 重写**(基类 `throw NotSupportedException`):`ToString`、`StartsWith`、`Contains`、`EndsWith`、`Substring`、`NullThen`、`JsonQuery`、`JsonSet` —— 字符串拼接、类型转换、空值处理、JSON 函数恰是各库差异最大处。 + +**子查询的优雅处理** —— 方法返回 `IExpSelect` 时识别为子查询,**递归复用整个 SelectBuilder 管线**而非表达式编译: + +```csharp +public virtual void Exits(IExpressionResolver resolver, MethodCallExpression methodCall) +{ + var builder = methodCall.CreateSelectBuilder(); + builder.SetResolveParentContext(resolver.Context); // 支持引用外层列 + builder.IsSubQuery = true; + resolver.Sql.AppendLine(resolver.IsNot ? "NOT EXISTS (" : "EXISTS ("); + builder.Build(resolver.Sql, resolver.Context.Database, resolver.Level + 1); + resolver.Sql.Append(')'); +} +``` + +这也是 AOT 改造的关键——子查询不用表达式编译。 + +#### `IDatabaseAdapter`(`Interfaces/IDatabaseAdapter.cs`) + +方言最高层抽象,成员包括:`Prefix` / `Emphasis`(参数前缀与标识符引用符)、`MethodResolver`、`UseIdentifierQuote` / `QuoteIdentifiers`、`DbCommandInit`、`Paging`、`ReturnIdentitySql`、`FormatBooleanValue` / `FormatDateTimeValue` / `HandleDateValue` / `HandleBooleanValue`、`IsKeyWord` / `AddKeyWord`、`HandleMultipleQuerySql` / `RewriteParameterReferences`、`HandleJsonColumn` / `HandleJsonParameter`、`HandleInsertOrUpdate` / `HandleBatchInsert` / `HandleBatchUpdate` / `HandleBatchDelete`。 + +`CustomDatabaseAdapter`(`Implements/CustomDatabaseAdapter.cs`,380 行)提供约 60 个保留字集合与批量操作通用 SQL 模板,分页/日期/JSON 默认 `throw NotSupportedException`。 + +### 3.7 缓存层:FNV-1a 哈希 + 结构/值分离 + +```csharp +private readonly record struct CacheKey(SqlAction SqlAction, ulong Hash); +private static readonly ConcurrentDictionary cache = new(); +``` + +**关键设计** + +| 机制 | 说明 | +| --------------------- | ------------------------------------------------------------------------------------------------ | +| FNV-1a 64 位 | `offset=0xCBF29CE484222325`,`prime=0x100000001B3`;喂入 NodeType、Type/Member/Method 的 MetadataToken | +| 参数名不参与哈希 | 默认 `includeParameterNames=false`,`VisitParameter` 只写类型不写名 → 结构相同的 lambda 共享缓存 | +| 常量值不参与哈希 | `x.Age > 10` 与 `x.Age > 20` 命中同一项 | +| `NeedToExtractValues` | 命中后单独调 `ExpressionValueExtract.Extract()` 重新抽取本次参数值 | +| `ContainVariable` | 标记表达式是否含闭包变量,决定是否走值提取 | + +即:**结构解析只做一次,变量值提取每次都做,两者分离**。这是 CTE 查询 135.6μs → 89.5μs 的原理。 + +`ExpressionValueExtract`(`Utils/ExpressionValueExtract.cs`,655 行)作为 `ExpressionVisitor` 从闭包常量中抽取运行时值;闭包 getter 编译成委托并按 `类型FullName_成员链名` 缓存,避免反射。 + + +### 3.8 高级 SQL 能力 + +| 能力 | 实现要点 | +| ---------- | -------------------------------------------------------------------------------------------------------------------------- | +| **CTE** | `AsTemp/WithTempQuery` 标记 `IsTemp+TempName`,`Build` 输出 `WITH name AS (...)`;`HandleTempsRecursion` 把内层 temp 提升到最外层,保证只声明一次 | +| **Union** | `SqlBuilder.AddUnion` → `Unions`;`Build` 逐片段追加 `UNION [ALL]` | +| **子查询** | `AsSubQuery()`;`Exits/Result` 走 Builder 管线递归 | +| **导航属性** | `Any/Include`:编译期 `ScanNavigate` 生成 JOIN;`Include` 也可延后到 `ToList` 后**另发 SQL** 按主键回写(`BindIncludeDatas`) | +| **分组聚合** | `GroupSelectProvider` + `FlatGrouping.Flat` 展平 `IExpSelectGrouping`;支持 ROLLUP/CUBE/GROUPING SETS | +| **窗口函数** | `WinFn.Lag/RowNumber/Rank` + `PartitionBy/OrderBy/Value` 链式拼接;`Utils/WindowFnSpecification.cs` 承载规格 | +| **JSON 列** | `LightJsonMap` 标记;`HandleJsonColumn` 生成方言 JSON 路径;`JsonQuery` → `JSON_VALUE`/`JSON_EXTRACT` | +| **批量操作** | `InsertBuilder.CreateInsertBatchSql` 分批(2000 列上限)→ `adapter.HandleBatchInsert`(SqlServer/MySql/Oracle/Dameng 走 BulkCopy) | +| **Upsert** | `OrUpdate/UpdateOnConflict` → `adapter.HandleInsertOrUpdate`(MERGE / ON CONFLICT) | +| **乐观锁** | `UpdateBuilder.WithVersion`,版本列自增 | +| **多结果集** | `QueryMultiple` → `adapter.HandleMultipleQuerySql` 拼接 + `RewriteParameterReferences` 改写参数前缀 → `MultipleResult` | + +### 3.9 性能设施(`Performances/` + `Utils/StringBuilderPool.cs`) + +| 池 | 作用 | +| -------------------------- | ---------------------------------------------------- | +| `ConnectionPool` | 按 Provider 分桶;15 分钟连接寿命健康检查;内存压力下延迟/直接 Dispose | +| `StringBuilderPool` | SQL 拼接复用,配合 `EstimateSqlLength` 预分配容量 | +| `SelectBuilderPool` | `SelectBuilder` 借还,重置 Joins/Where/分页,超大列表收缩 | +| `ExpressionResolverPool` | 重置 Sql/参数/状态,容量过大则重建 StringBuilder | +| `ExpressionVisitorPool` | 泛型 `ExpressionVisitor` + `IResetable` 复用 | +| `SlimList` | struct,前 4 元素内联、超出才转数组,零分配小列表 | +| `ObjectPool` | 通用基类:`_fastItem` 快速路径 + `ConcurrentQueue` + 5 分钟健康检查 | + +--- + +## 4. 主线 B:DbDataReader → 对象(反序列化委托) + +> 严格说是**反序列化**(reader → 对象)。项目提供两条并行的委托生成路径。 + +### 4.1 两条路径对比 + +| | 运行时动态编译路径 | AOT 静态生成路径 | +| ------ | ---------------------------------- | -------------------------------------------- | +| 实现 | `SqlExecutor/ExpressionBuilder.cs` | `LightOrmTableContextGenerator` 源生成器 | +| 机制 | `Expression.Lambda(...).Compile()` | 编译期生成 C# 静态方法 | +| 适用 | 任意类型(实体/匿名/元组/基础类型) | 仅标注 `[LightTable]` 的具名实体 | +| 产物 | `Func` 委托,进程内缓存 | `ITableEntityInfo.DataReaderDeserializer` | +| AOT 安全 | ❌ 依赖动态代码 | ✅ | + + +### 4.2 运行时路径:`ExpressionBuilder` 全流程 + +入口 `BuildDeserializer(DbDataReader reader)`: + +``` +GenerateCacheKey(type, reader) ← 类型 FullName + 每列「列名:DataType:AllowDBNull」 + │ 命中 dynamicDelegates 缓存?直接返回 + ▼ +BuildFunc(reader, CultureInfo) + │ + ├─ ParameterExpression recordInstanceExp = Parameter(typeof(IDataReader), "reader") + ├─ DataTable schemaTable = reader.GetSchemaTable() ← 取列可空性 + │ + ├─ 按目标类型四路分派 ──────────────────────────────┐ + │ │ + ▼ Expression.Lambda>(body).Compile() +``` + +#### 类型分派 + +| 目标类型 | 生成形态 | +| -------------------------------------------------------------------- | ------------------------------------------------------- | +| `System.Tuple<...>` | `Expression.New(ctor, args)` —— 按构造参数位置取列,最多 7 元 | +| 基础类型(`int`/`string`/`Guid`/`DateTime`… 及可空版,见 `Ex.IsElementaryType`) | 只取第 0 列 | +| 匿名类型 | `Expression.New(ctor, args)` —— 按**属性声明顺序**匹配 ctor 参数 | +| 具名实体 | `Expression.MemberInit(Expression.New(type), bindings)` | + +具名实体还额外处理三类特殊列: + +- **普通列** —— 跳过 `IsNotMapped / IsNavigate / IsAggregated / IsAggregatedProperty / IsJsonColumn` +- **JSON 列** —— 走 `GetTargetJsonExpression` +- **聚合列(Flat)** —— 按 `AggregateType` 分组,生成一个嵌套 `MemberInit` +- 列匹配规则 `MemberMatchesName`:`PropertyName` 或 `ColumnName` 与 `reader.GetName(i)` **忽略大小写**相等 + +#### 每个成员的表达式由三段拼成 + +```csharp +// ① 取值:reader.GetXxx(i) +Expression RecordFieldExpression = GetRecordFieldExpression(...); +// ② 转换:类型对齐 / Parse / Convert +Expression Converted = GetConversionExpression(RecordFieldType, RecordFieldExpression, TargetType, Culture); +// ③ 空值:AllowDBNull 则包一层三元 +Expression final = AllowDBNull + ? Expression.Condition( + Expression.Call(reader, IsDBNull, Constant(i)), // reader.IsDBNull(i) + Expression.Default(TargetMemberType), + Converted, + TargetMemberType) + : Converted; +``` + +生成的目标形态(源码注释原文): + +```csharp +reader => new T { + Member0 = (T0)reader.GetInt32(0), + Member1 = (T1)reader.GetString(1), + Member4 = reader.IsDBNull(4) ? default(T4) : (T4)reader.GetDecimal(4), +} +``` + +#### 取值方法映射(`ExpressionBuilder.ReflectMethod.cs`) + +`typeMapMethod: Dictionary` 覆盖 `byte/sbyte/short/ushort/int/uint/long/ulong/float/double/decimal/bool/string/char/Guid/DateTime/byte[]`;未命中回退 `IDataRecord.GetValue`。 + +三个特殊类型用自定义静态辅助方法兜底(`ExpressionBuilder.ExternalHelper.cs`): + +| 方法 | 用途 | +| --------------------------- | ------------------------------------------------ | +| `RecordFieldToUInt16/32/64` | 无符号类型:先 GetIntXx 再判负抛 `OverflowException` | +| `RecordFieldToBytes` | 先 `GetBytes(col,0,null,0,0)` 取长度再分配缓冲,空数据返回 `[]` | +| `CustomStringToBoolean` | 宽松解析 `",是,1,Y,YES,TRUE,"` | +| `GetSafeIntermediateType` | decimal 与浮点/整数互转的中间类型选择,防溢出与精度损失 | + +#### 类型转换矩阵(`GetConversionExpression`) + +| 源 → 目标 | 策略 | +| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 同类型 / 底层类型相同 | 原样 | +| `string` → T | `GetParseExpression`:`T.Parse(string, NumberFormatInfo)`;枚举走 `Enum.Parse(type, s, true)`;DateTime 带 `DateTimeFormatInfo`;bool 走宽松解析;不支持则抛 `LightOrmException` | +| T → `string` | `Convert.ToString(src)` | +| → `bool` / `bool?` | `Convert.ToBoolean(src)` | +| `byte[]` → T | `byte[]` 原样;`MemoryStream` → `new MemoryStream(bytes)`;其余抛异常 | +| 其余 | `Expression.Convert` | +| 目标为可空且未转换过 | 再包一层 `Convert` 到 `Nullable` | + +#### JSON 列 + +`GetTargetJsonExpression` 把取值结果交给 `StringDeserializer` / `BytesDeserializer`,即 `ExpressionBuilder.RecordFieldStringDeserializer(value, targetType)` → `ILightJsonHelper.Deserialize(value, targetType)`。目标类型通过 `Expression.Constant(TargetType)` 内联进表达式;JSON 类型集合由 `ExpressionBuilder.AddJsonTypeMap(type)` 注册。 + +#### 缓存键 + +```csharp +$"{type.FullName}|{列名}:{DataType}:{AllowDBNull}|{列名}:...|" +``` + +即"**类型 + 结果集 schema**"共同决定一份委托——同名类型在不同查询列结构下各自缓存一份。 + +### 4.3 AOT 路径:源生成器 + +`[LightORMTableContext]` 标注在 `partial class` 上 → 生成器扫描编译期所有 `[LightTable]` 实体 → 为每个实体生成 `LightORM.GeneratedTableContext.{Type}TableInfo.g.cs`,产出: + +| 生成成员 | 说明 | +| ----------------------------------------------------------------------- | ----------------------------------------------------------- | +| `private static Lazy columns` | 延迟构建,`Columns => columns.Value` | +| `CollectColumnInfo()` | 纯 `new ColumnInfo(...)` 字面量,**零反射** | +| `Type / TableName / Schema / CustomName / TargetDatabase / Description` | 元数据 | +| `static GetValue(col, target)` | `switch(PropertyName)` 直读 | +| `static SetValue(col, target, value)` | `switch(PropertyName)` 直写,Flat 属性自动 new 子对象 | +| `HandleInclude / HandleIncludeAsync` | AOT 安全的导航属性加载(替代反射版 `BindIncludeDatas`) | +| `DataReaderDeserializer` | `Func?`,指向 `Deserialize{T}FromDbDataReader` | +| `Deserialize{T}FromDbDataReader(reader)` | **静态反序列化方法** | + +同时生成一个聚合 partial 类,维护 `tableInfos/table_sets/table_gets` 三个字典并暴露 `GetTableInfo/GetSetMethod/GetGetMethod`(用 `IsAssignableFrom` 回退到基类/接口)。 + +### 4.4 AOT 判定与降级 + +```csharp +// AssemblyInfo.cs +public static bool AOTSupported = false; // 由 ExpressionSqlBuilder 置 true +public static bool IsAOTRuntime => !RuntimeFeature.IsDynamicCodeSupported && AOTSupported; +``` + +即:**只有同时满足「运行时不支持动态代码」且「用户配置了生成器上下文」两个条件,才算 AOT 运行时**。`EnsureReflectionAccess(type)` 在"不支持动态代码 + 非匿名类型 + 未启用 AOTSupported"时抛出带解决方案说明的 `NotSupportedException`。 + +AOT 下的行为差异: + +| 位置 | 行为 | +| --------------------------------------------------- | ---------------------------------------------------------------------- | +| `IncludeContextExtensions.BindIncludeDatas` | 抛 `LightOrmException`(反射 Include 不可用)→ 改用生成器产出的 `HandleInclude` | +| `SqlExecutorExtensions.Query(sql, object param)` | 抛 `NotSupportedException`,提示改调 `Execute` | +| `ExpressionBuilder` 匿名类型嵌套 | `IsAOTRuntime` 时抛 `LightOrmException("嵌套的匿名类型会被裁剪")` | +| `LightOrmAotAnalyzer` | 编译期诊断 **TCGA00001**:程序集声明 `IsAotCompatible` 时对非 `Execute` 的扩展方法调用告警 | +| 生成器诊断 | `TCG00001`(需实现 ITableContext)、`TCG00002`(生成异常) | + +### 4.5 现状与缺口(源码实测) + +| 项 | 状态 | +| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `LightOrmTableContextGenerator/TableContextGenerator.CreateDeserializeMethod.cs` | ⚠️ **方法体是 `throw new NotImplementedException()`**,完整实现整体注释掉了(`reader.FieldCount` 循环 + `switch(列名)` + `GetValueExpression` 的骨架都在注释里)。即 **AOT 静态反序列化路径当前不可用**,实际仍全部走 `ExpressionBuilder` 动态编译 | +| `Cache/DeserializerCache.cs` | ⚠️ 空壳,`GetDeserializer` 直接 `throw new NotImplementedException()` | +| `Utils/ExpressionAotHelper.cs` | 空桩类,预留位 | +| `SqlExecutor/OrignalSqlExecutor.cs` | 标记 `[Obsolete]`,但仍是主执行实现 | +| `Models/TypeSet.cs` | 内容已注释,实际由生成器产出 | +| `Cache/StaticCache` | `[Obsolete(true)]` | +| `AssemblyInfo.cs` 调试开关 | `ShowSqlExecutorDebugInfo = true`、`ShowExpressionHashCodeDebugInfo = true`(发布前建议关) | + +--- + +## 5. 源生成器体系 + +### 5.1 `LightOrmExtensionGenerator` + +由 `GeneratorBase` 统一驱动,监听**程序集级**特性(在核心库 `AssemblyInfo.cs` 中声明 17 行): + +```csharp +[assembly: SelectExtension(ArgumentCount = 2)] // ... 一直到 = 17 +``` + +| 生成器 | 产出 | +| -------------------------------- | -------------------------------------------------------------------------------- | +| `SelectExtensionGenerator` | `SelectExtensions.Select`、`WhereIf`、`ToDynamicList`、`ToDataTable` 等扩展方法 | +| `SelectInterfacesGenerator` | `IExpSelect` 接口 | +| `SelectProvidersGenerator` | `SelectProvider{n}`,链式 `InnerJoin/LeftJoin` 返回 `SelectProvider{n+1}` | +| `TypeSetGenerator` | `TypeSet` 元组式投影容器,暴露 `Tb1..Tb17` | +| `SqlMethodResolverCtorGenerator` | 监听 `BaseSqlMethodResolver`,把其所有虚方法注册进 `methods` 字典 | + +生成的方法普遍标注 `[DynamicallyAccessedMembers(PublicConstructors|PublicProperties)]`,引导裁剪器保留反序列化所需成员。 + +### 5.2 `GenShared/Generators.Shared` —— 代码生成 DSL + +一套轻量 fluent DSL,让生成器拼代码而非拼字符串: + +- `Node`(`Builder/Member.cs`)抽象基类:`Parent/Indent/Level`,`Indent = 4 * Level` 自动缩进 +- 构建器:`ClassBuilder` / `MethodBuilder` / `PropertyBuilder` / `FieldBuilder` / `ConstructorBuilder` / `NamespaceBuilder`(支持 `FileScoped`) +- `Statement` 通过 `implicit operator Statement(string)` 让字符串直接当语句并自动补分号 +- 控制流:`IfStatement` / `ForeachStatement` / `SwitchStatement` / `TryCatch` / `LocalFunction` +- 顶层入口:`CodeFile.New(name).AddMembers(ns).AddUsings(...)` + +--- + +## 6. 方言适配层(`src/Providers/`) + +### 6.1 三层抽象 + +| 层次 | 契约 | 基类 | 职责 | +| --------- | ----------------------- | ------------------------------ | ------------------------------- | +| **适配器** | `IDatabaseAdapter` | `CustomDatabaseAdapter` | 标识符引用符、分页、布尔/日期字面量、批量模板、JSON 函数 | +| **方法解析器** | `ISqlMethodResolver` | `BaseSqlMethodResolver` | 函数名映射、LIKE 拼接、类型转换、JSON 函数 | +| **表处理器** | `IDatabaseTableHandler` | `BaseDatabaseHandler` | 建表 DDL、库表结构读取、批量写入具体实现 | + +### 6.2 SqlServer vs Sqlite 差异一览 + +| 维度 | SqlServer | Sqlite | | | | | +| ------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------- | - | -- | - | ----- | +| 分页 | `OFFSET n ROWS FETCH NEXT m ROWS ONLY` | `LIMIT skip, take` | | | | | +| 引用符 | `[col]` | `` `col` `` | | | | | +| 自增回写 | `SELECT SCOPE_IDENTITY()` | `SELECT LAST_INSERT_ROWID()` | | | | | +| 日期字面量 | `CONVERT(DATETIME,'...',120)` | 直接 `'yyyy-MM-dd HH:mm:ss'` | | | | | +| LIKE 拼接 | `'%'+@p+'%'` | \`'%' | | @p | | '%'\` | +| 空值函数 | `ISNULL` | `IFNULL` | | | | | +| `ToString` 日期 | `CONVERT(VARCHAR(MAX),col,style)` —— **把 .NET 格式串映射成 style code**(`"yyyy-MM-dd"`→23,`"yyyyMMdd"`→112) | `STRFTIME('%Y-%m-%d %H:%M:%S',col)` | | | | | +| JSON | `JSON_VALUE` / `JSON_MODIFY` | `JSON_EXTRACT` / `JSON_SET`(Binary 用 JSONB\_*) | | | | | +| Upsert | `MERGE INTO ... WHEN MATCHED` | `INSERT ... ON CONFLICT(pk) DO UPDATE SET EXCLUDED` | | | | | +| 分组聚合 | `STRING_AGG`(按 `SqlServerVersion` 决定,2017+ 才支持,否则抛异常) | `GROUP_CONCAT` | | | | | +| 批量插入 | `SqlBulkCopy` | 不支持(多行 VALUES) | | | | | + +**版本感知**:`SqlServerMethodResolver` 构造接收 `SqlServerVersion` 枚举,同一 SQL 片段在不同版本生成不同函数(如 `TRIM` 在 2017+ 用原生)。 + +### 6.3 新增一个数据库 = 实现 5 个类 + +``` +Custom{DB}Adapter : CustomDatabaseAdapter (+ .BatchInsert.cs / .InsertOrUpdate.cs partial) +{DB}MethodResolver : BaseSqlMethodResolver +{DB}Provider : BaseDatabaseProvider +{DB}TableHandler : BaseDatabaseHandler<{DB}TableOptions> (+ .Writer.cs) +{DB}TableOptions : TableOptions +Extensions/IoCExtension.cs (AddLightOrmXxx 注册入口) +``` + +--- + + +## 7. 执行层(`src/LightORM/SqlExecutor/`) + +| 类型 | 文件 | 职责 | +| -------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `SqlAdo` | `SqlAdo.cs`(745 行,最大文件) | `readonly struct`,`DatabaseConnection` + `AdoInterceptor` 的轻封装;全套同步/异步 `ExecuteNonQuery/Scalar/Reader/QueryMultiple/DataSet/DataTable`;内部 `PrepareCommand` 开连接、`DbCommandInit`、挂事务、`HandleDbParameter`、拦截器通知、`StopwatchHelper` 计时 | +| `ExecuteResult` | `ExecuteResult.cs` | `Ado.Execute(sql, param)` 返回;链式 `ToList/Single/ToListAsync/SingleAsync`;NET8 另有 `ToAsyncList`(IAsyncEnumerable)与 dynamic 重载 | +| `OrignalSqlExecutor` | `OrignalSqlExecutor.cs` + `.Prepare.cs` + `.Trans.cs` | `ISqlExecutor` 主实现(当前标记 `[Obsolete]`);7 类执行方法的同步/异步版本 | +| `InternalDataReader` | `InternalReader.cs` | `DbDataReader` 装饰器:`Close()` 时清参数、Dispose 命令、**把连接归还连接池** | +| `EmptyDataReader` | 同上 | 拦截器吞掉异常时的空读器 | +| `MultipleResult` | `Models/MultipleResult.cs` | 多结果集,每次 `Read*` 消耗一个结果集 | +| `DatabaseConnection` | `DatabaseConnection.cs`(339 行) | 另一套基于 `DbTransaction` 的封装 | +| `MapperTable` | `MapperTable.cs`(330 行) | 映射表 | +| `CommandResult` | `CommandResult.cs` | 命令 + 连接 + `NeedToReturn` 的组合 | + +**事务**:`ConcurrentDictionary>` + 每 executor 的 `AsyncLocal CurrentTransactionContext`,支持异步流穿透;`Begin/Commit/Rollback` 支持嵌套(Savepoints + `NestLevel`),异常时置 `IsOccurException` 阻断后续命令。 + +**拦截器**:`IAdoInterceptor` 提供 `Before/AfterExecute`、`OnException`、`OnPrepareCommand`;`AdoInterceptorBase` 默认 `Debug.WriteLine`;DI 中 `UseInterceptor` 注册(无参构造按无状态缓存,否则 Scoped)。 + +--- + + +## 8. 周边设施 + +| 设施 | 位置 | 说明 | +| ----------- | ----------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| **仓储模式** | `Repository/DefaultRepository.cs`、`ILightOrmRepository.cs` | `ILightOrmRepository` 暴露 `Table`(IQueryable)、`ExpSelect`、CRUD/批量/Async、`SaveChanges`;`DefaultRepository` 为 Scoped,内部用事务包裹 | +| **LINQ 支持** | `Repository/LightOrmQuery.cs`、`LightOrmQueryProvider.cs` | 实现 `IQueryable`/`IQueryProvider`,把 Where/OrderBy/Join/GroupBy/Select/Skip/Take 翻译成 `SelectBuilder` | +| **SQL 函数桩** | `Utils/SqlFn.cs`、`SqlFn.Json.cs`、`WinFn.cs`、`WindowFnSpecification.cs` | `SqlFn.In/Abs/Round/Count/Sum/Average/Max/NullThen/Coalesce/Grouping/Case/Join/JsonQuery/JsonSet`、`WinFn.Lag/RowNumber/Rank` —— 方法体只返回默认值,**在表达式树中占位**,由 `BaseSqlMethodResolver` 翻译成 SQL | +| **表结构** | `DbStruct/` + `Implements/ReadTypeFromTable.cs`、`WriteTableFromType.cs` | 实体 ↔ DDL 双向:`GenerateDbTable`、`GetTablesSql`、`GetTableStructSql`、`ParseDataType`;`TableOptions` 配置 `UseUnicodeString`/`JSONBackend`/`DefaultStringLength` | +| **DI 扩展** | `LightORM.Extensions.DependencyInjection/IoCExtensions.cs` | `AddLightOrm` 注册 Scoped `IExpressionContext`(ExpressionCoreSql)、`ILightOrmRepository<>`→`DefaultRepository<>`,并收集 `IAdoInterceptor` | +| **JSON 抽象** | `Interfaces/ILightJsonHelper.cs`、`Implements/DefaultJsonHelper.cs` | 可替换的 JSON 后端(`option.ConfigJsonHandler()`) | +| **DbUtils** | `DatabaseUtils/` | 独立数据库管理工具项目 | + +--- + +## 9. 测试与基准 + +| 工程 | 用途 | +| --------------------------------------------------------------------- | ------------------ | +| `test/LightORMTest` | 核心测试(基类与通用用例) | +| `test/LightORMTest.{Sqlite,MySql,Oracle,PostgreSQL,SqlServer,Dameng}` | 各方言的端到端测试 | +| `test/BenchmarkTest` | BenchmarkDotNet 压测 | +| `test/PerformanceTest`、`SqlGenerateTest` | 性能与 SQL 生成验证 | +| `test/TestWeb` | Web 集成样例 | +| `test/TestProject1` | 早期试验工程 | + +`examples.md`(18KB)是完整的 API 示例手册,覆盖:注册配置、生成器用法、基础/Join/多表/子查询/Join子查询/CTE/Include/Union 查询、聚合与开窗函数、更新/插入/删除、JSON 列、Ado 对象、事务、仓储与 LINQ、复杂查询。 + +--- + +## 10. 关键设计权衡与技术债 + +### 已经做对的 + +1. **解析器 / 组装器 / 方言三层分离** —— 支持 7 个数据库而代码不臃肿的根本原因 +2. **结构解析一次 + 值提取每次** —— 缓存命中率与正确性的平衡 +3. **子查询复用 Builder 管线而非表达式编译** —— 一举兼顾性能与 AOT +4. **源生成器替代运行时反射** —— 实体元数据、GetValue/SetValue、Include 全静态化 +5. **对象池全覆盖** —— StringBuilder/SelectBuilder/Resolver/Visitor/Connection 五类 + +### 现存缺口(按优先级) + +| 优先级 | 问题 | 位置 | +| ------ | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- | +| **P0** | AOT 静态反序列化未实现,生成的方法体是 `throw new NotImplementedException()`,完整骨架留在注释里 | `TableContextGenerator.CreateDeserializeMethod.cs` | +| **P0** | `ExpressionBuilder` 整体依赖 `Expression.Compile()` + `GetSchemaTable()`,AOT 下不可用且部分 ADO 驱动 `GetSchemaTable` 返回 null | `SqlExecutor/ExpressionBuilder.cs` | +| **P1** | `DeserializerCache` 空壳未实现 | `Cache/DeserializerCache.cs` | +| **P1** | `OrignalSqlExecutor` 标记 `[Obsolete]` 但仍是主实现,缺少替代路径 | `SqlExecutor/OrignalSqlExecutor.cs` | +| **P2** | `AssemblyInfo.cs` 中 `ShowSqlExecutorDebugInfo`/`ShowExpressionHashCodeDebugInfo` 默认 `true` | `AssemblyInfo.cs` | +| **P2** | `Models/TypeSet.cs` 内容注释、依赖生成器产出;`StaticCache` 已废弃 | `Models/TypeSet.cs`、`Cache/StaticCache.cs` | +| **P3** | `Providers/` 命名与 `src/Providers/` 冲突,易误读 | 目录结构 | + +--- + + +## 11. 推荐阅读路线 + +**想理解「表达式怎么变成 SQL」**(约 2 小时) + +1. `Interfaces/ExpSql/IExpSelect`1.cs\` —— 看流式 API 长什么样 +2. `Providers/Select/SelectProvider0.cs` —— 看一次 `Where` 调用落到哪里 +3. `Builder/SelectBuilder.cs` 的 `HandleResult` + `Build` —— 看片段如何收集与组装 +4. `Utils/ExpressionResolver.cs` 的 `VisitXXX` 系列 —— **核心**,逐节点看翻译 +5. `Utils/ResolveContext.cs` —— 看表别名与父子作用域 +6. `Implements/BaseSqlMethodResolver.cs` —— 看 C# 方法 → SQL 的映射表 + +**想理解「DbDataReader 怎么变成对象」**(约 1 小时) + +1. `SqlExecutor/Extensions/SqlExecutorExtensions.cs` 的 `Query` —— 入口 +2. `SqlExecutor/ExpressionBuilder.cs` 的 `BuildDeserializer` → `BuildFunc` —— 主流程 +3. `GetRecordFieldExpression` / `GetConversionExpression` / `GetTargetValueExpression` —— 三段构造 +4. `SqlExecutor/ExpressionBuilder.ReflectMethod.cs` + `.ExternalHelper.cs` —— 取值方法表与特殊类型 +5. `src/LightOrmTableContextGenerator/TableContextGenerator.CreateDeserializeMethod.cs` —— AOT 路径(当前是坑) + +**想新增一个数据库方言**(约 半天) + +1. 复制 `src/Providers/LightORM.Providers.Sqlite/` +2. 依次实现 `Custom{DB}Adapter` / `{DB}MethodResolver` / `{DB}Provider` / `{DB}TableHandler` / `{DB}TableOptions` / `IoCExtension` +3. 在 `test/LightORMTest.{DB}` 补端到端测试 + +--- + +## 附录 A:文件规模 TOP 15(核心库) + +| 行数 | 文件 | +| ------- | ------------------------------------------------- | +| 745 | `SqlExecutor/SqlAdo.cs` | +| 719 | `Implements/BaseSqlMethodResolver.cs` | +| 677 | `SqlExecutor/OrignalSqlExecutor.cs` | +| 674 | `Utils/ExpressionResolver.cs` | +| 655 | `Utils/ExpressionValueExtract.cs` | +| 649 | `Builder/SelectBuilder.cs` | +| **638** | **`SqlExecutor/ExpressionBuilder.cs`**(反序列化委托生成) | +| 595 | `Utils/Vistors/ExpressionHasher.cs` | +| 534 | `Providers/Select/SelectProvider1.cs` | +| 499 | `Providers/Select/SelectProvider2.cs` | +| 463 | `Providers/Select/SelectProvider0.cs` | +| 401 | `Models/TypeSet.cs`(已注释,实际由生成器产出) | +| 398 | `Builder/UpdateBuilder.cs` | +| 381 | `SqlExecutor/Extensions/SqlExecutorExtensions.cs` | +| 380 | `Implements/CustomDatabaseAdapter.cs` | + +## 附录 B:两条主线关键类速查 + +| 主线 A(写方向) | 主线 B(读方向) | +| ------------------------- | ----------------------------------------------- | +| `IExpressionContext` | `SqlAdo` | +| `IExpSelect` | `ExecuteResult` | +| `SelectProvider0/1/2..16` | `ExpressionBuilder.BuildDeserializer` | +| `SelectBuilder` | `ExpressionBuilder.BuildFunc` | +| `ExpressionResolver` | `GetRecordFieldExpression` | +| `ResolveContext` | `GetConversionExpression` | +| `ISqlMethodResolver` | `GetTargetValueExpression` | +| `IDatabaseAdapter` | `GetTargetJsonExpression` | +| `ExpressionHasher` | `ITableEntityInfo.DataReaderDeserializer` | +| `ExpressionValueExtract` | `TableContextGenerator.CreateDeserializeMethod` | diff --git a/src/LightORM/AssemblyInfo.cs b/src/LightORM/AssemblyInfo.cs index 32f9f37d..b414a5cd 100644 --- a/src/LightORM/AssemblyInfo.cs +++ b/src/LightORM/AssemblyInfo.cs @@ -43,6 +43,7 @@ internal static class DebugControl public static readonly bool ShowExpressionResolveDebugInfo = false; public static readonly bool ShowSqlExecutorDebugInfo = true; public static readonly bool ShowExpressionHashCodeDebugInfo = true; + public static readonly bool ShowObjectPoolDebugInfo = false; } internal static class BenchmarkConfig diff --git a/src/LightORM/Builder/InsertBuilder.cs b/src/LightORM/Builder/InsertBuilder.cs index 7eed6ca5..53c3915d 100644 --- a/src/LightORM/Builder/InsertBuilder.cs +++ b/src/LightORM/Builder/InsertBuilder.cs @@ -110,12 +110,12 @@ public override string ToSqlString(IDatabaseAdapter database) // ToSqlString由内部或者测试项目调用,批量情况下查看SQL使用BatchInfos属性 return string.Empty; } + ResolveExpressions(database); if (TargetObject == null && DbParameters.Count == 0) { throw new LightOrmException("插入的实体为空或者没有需要插入的值"); } - ResolveExpressions(database); var insertColumns = GetInsertColumns(); diff --git a/src/LightORM/Builder/ScopedDatabaseAdapter.cs b/src/LightORM/Builder/ScopedDatabaseAdapter.cs index 99ad1c3a..28bf213b 100644 --- a/src/LightORM/Builder/ScopedDatabaseAdapter.cs +++ b/src/LightORM/Builder/ScopedDatabaseAdapter.cs @@ -88,4 +88,6 @@ public void ReturnIdentitySql(StringBuilder sql) void IDatabaseAdapter.HandleInsertOrUpdate(UpsertContext context) => inner.HandleInsertOrUpdate(context); void IDatabaseAdapter.HandleBatchDelete(BatchActionContext> context) => inner.HandleBatchDelete(context); + + void IDatabaseAdapter.HandleSelectGroupBySegment(SelectContext context) => inner.HandleSelectGroupBySegment(context); } diff --git a/src/LightORM/Builder/SelectBuilder.cs b/src/LightORM/Builder/SelectBuilder.cs index 680f8962..a8e01b17 100644 --- a/src/LightORM/Builder/SelectBuilder.cs +++ b/src/LightORM/Builder/SelectBuilder.cs @@ -42,6 +42,7 @@ internal partial class SelectBuilder : SqlBuilder, ISelectSqlBuilder public List TempViews { get; } = []; public SelectBuilder? SubQuery { get; set; } public List Unions { get; } = []; + public HashSet SelectedMembers { get; set; } = []; public bool IsSubQuery { get; set; } public bool IsTemp { get; set; } public bool IsUnion { get; set; } @@ -54,6 +55,7 @@ internal partial class SelectBuilder : SqlBuilder, ISelectSqlBuilder public bool IsCube { get; set; } public string SelectValue { get; set; } = "*"; public int Depth { get; set; } + private readonly List joins = []; public List Having { get; set; } = []; public SortedSet Includes { get; set; } = []; @@ -61,6 +63,7 @@ internal partial class SelectBuilder : SqlBuilder, ISelectSqlBuilder public string? GroupBy { get; set; } public List GroupingSets { get; set; } = []; public List OrderBy { get; set; } = []; + public HashSet OrderByMembers { get; set; } = []; public int TableIndexFix { get; set; } public object? AdditionalValue { get; set; } public int NextTableIndex => SelectedTables.Count + joins.Count + TableIndexFix; @@ -191,6 +194,7 @@ protected override void HandleResult(IDatabaseAdapter database, ExpressionInfo e } } } + SelectedMembers.AddRange(result.SelectedMembers); if (!string.IsNullOrWhiteSpace(result.SqlString)) { SelectValue = result.SqlString!; @@ -209,6 +213,7 @@ protected override void HandleResult(IDatabaseAdapter database, ExpressionInfo e } else if (expInfo.ResolveOptions.SqlType == SqlPartial.OrderBy) { + OrderByMembers.AddRange(result.Members); OrderBy.Add(result.SqlString!); AdditionalValue = expInfo.AdditionalParameter; } @@ -321,7 +326,6 @@ public override string ToSqlString(IDatabaseAdapter database) return sqlString; } - private const string UNIT_IDENT = " "; public void Build(StringBuilder sql, IDatabaseAdapter database, int currentLevel) { Depth = currentLevel; @@ -436,33 +440,7 @@ public void Build(StringBuilder sql, IDatabaseAdapter database, int currentLevel } if (GroupBy is { }) { - if (IsRollup) - { - // $"{ident}GROUP BY ROLLUP ({string.Join(", ", GroupBy)})" - sql.Append(ident).Append("GROUP BY ROLLUP (").Append(GroupBy).AppendLine(")"); - } - else if (IsCube) - { - // $"{ident}GROUP BY CUBE ({string.Join(", ", GroupBy)})" - sql.Append(ident).Append("GROUP BY CUBE (").Append(GroupBy).AppendLine(")"); - } - else if (GroupingSets.Count > 0) - { - sql.Append(ident).AppendLine("GROUP BY GROUPING SETS ("); - foreach (var set in GroupingSets) - { - sql.Append(ident).Append(UNIT_IDENT) - .Append('(').Append(set).Append(')').AppendLine(","); - } - sql.RemoveLast(N.Length + 1); - sql.AppendLine(); - sql.Append(ident).AppendLine(")"); - } - else - { - // $"{ident}GROUP BY {string.Join(", ", GroupBy)}" - sql.Append(ident).Append("GROUP BY ").Append(GroupBy).AppendLine(); - } + database.HandleSelectGroupBySegment(new(this, sql, database, ident)); } if (Having.Count > 0) { diff --git a/src/LightORM/Builder/SqlBuilder.cs b/src/LightORM/Builder/SqlBuilder.cs index b36f389b..af88fa37 100644 --- a/src/LightORM/Builder/SqlBuilder.cs +++ b/src/LightORM/Builder/SqlBuilder.cs @@ -9,6 +9,8 @@ namespace LightORM.Builder; //internal readonly struct internal abstract partial class SqlBuilder : ISqlBuilder { + + public const string UNIT_IDENT = " "; public static string N { get; } = Environment.NewLine; public ExpressionInfoProvider Expressions { get; } = new ExpressionInfoProvider(); public TableInfo MainTable => SelectedTables[0]; @@ -108,6 +110,7 @@ protected void ResolveExpressions(IDatabaseAdapter database) var result = item.Expression.Resolve(item.ResolveOptions, ResolveCtx); if (!string.IsNullOrEmpty(item.Template)) { + result = result with { }; result.SqlString = string.Format(item.Template, result.SqlString); } HandleResult(database, item, result); diff --git a/src/LightORM/Builder/UpdateBuilder.cs b/src/LightORM/Builder/UpdateBuilder.cs index 57e4bd8c..8e1ff035 100644 --- a/src/LightORM/Builder/UpdateBuilder.cs +++ b/src/LightORM/Builder/UpdateBuilder.cs @@ -40,6 +40,7 @@ private static ITableColumnInfo GetColumn(TableInfo tableInfo, string propertyNa public bool IsBatchUpdate { get; internal set; } public VersionInfo VersionInfo { get; set; } public bool UseVersionColumn { get; private set; } + public int SetCount => Members.Count + SetNullMembers.Count; public void AddMember(string member, object? value) { Members.Add(member); @@ -184,13 +185,6 @@ private void CreateUpdateBatchSql(IDatabaseAdapter database) if (IgnoreMembers.Count > 0 && IgnoreMembers.Contains(col.PropertyName)) return false; - // 如果 Members 为空,且当前列不是被强制保留的类型,则需进一步判断 - if (Members.Count == 0) - { - // 当 Members 为空时,只要没被 Ignore 就保留 - return true; - } - // Members 非空:只保留显式指定的成员,主键、版本号等始终保留 if (col.IsPrimaryKey || col.IsVersionColumn) return true; @@ -199,6 +193,13 @@ private void CreateUpdateBatchSql(IDatabaseAdapter database) if (col.AutoIncrement || col.IsNotMapped || col.IsNavigate || col.IsAggregated || col.IsIgnoreUpdate) return false; + // 如果 Members 为空,且当前列不是被强制保留的类型,则需进一步判断 + if (Members.Count == 0) + { + // 当 Members 为空时,只要没被 Ignore 就保留 + return true; + } + // 最终:是否在 Members 中 return Members.Contains(col.PropertyName); }) @@ -308,18 +309,26 @@ public override string ToSqlString(IDatabaseAdapter database) } sb.AppendEmphasis(c.ColumnName, database); sb.Append(" = "); - sb.WithPrefix(c.PropertyName, database); - if (c.IsJsonColumn) + if (value is bool b) { - // TODO 暂时做法,兼容postgresql,在后面追加::JSONB - database.HandleJsonParameter(new(ActionType.Parameterized, c, sb, null, DbParameters, ExpressionSqlOptions.Instance.Value.GetJsonHandler())); - var jsonHandler = ExpressionSqlOptions.Instance.Value.GetJsonHandler(); - var jsonString = jsonHandler.Serialize(value); - DbParameters[c.PropertyName] = jsonString; + sb.Append(database.FormatBooleanValue(b)); + DbParameters.Remove(c.PropertyName); } - if (!valueFounded) + else { - DbParameters.Add(c.PropertyName, value!); + sb.WithPrefix(c.PropertyName, database); + if (c.IsJsonColumn) + { + // TODO 暂时做法,兼容postgresql,在后面追加::JSONB + database.HandleJsonParameter(new(ActionType.Parameterized, c, sb, null, DbParameters, ExpressionSqlOptions.Instance.Value.GetJsonHandler())); + var jsonHandler = ExpressionSqlOptions.Instance.Value.GetJsonHandler(); + var jsonString = jsonHandler.Serialize(value); + DbParameters[c.PropertyName] = jsonString; + } + if (!valueFounded) + { + DbParameters.Add(c.PropertyName, value!); + } } sb.AppendLine(","); diff --git a/src/LightORM/ExpressionSql/ExpressionCoreSql.Tran.cs b/src/LightORM/ExpressionSql/ExpressionCoreSql.Tran.cs index 8c90190d..f5bae6d1 100644 --- a/src/LightORM/ExpressionSql/ExpressionCoreSql.Tran.cs +++ b/src/LightORM/ExpressionSql/ExpressionCoreSql.Tran.cs @@ -8,6 +8,7 @@ public ISingleScopedExpressionContext Use(IDatabaseProvider db) { var connection = connectionFactory.GetDatabaseConnection(db); + connection.KeepAlive = true; return new SingleScopedExpressionCoreSql(connection, Options); } @@ -15,6 +16,7 @@ public ISingleScopedExpressionContext CreateScoped(string key) { Debug.WriteLine("CreateScoped"); var connection = connectionFactory.GetDatabaseConnection(key); + connection.KeepAlive = true; return new SingleScopedExpressionCoreSql(connection, Options); } diff --git a/src/LightORM/ExpressionSql/ScopedExpressionCoreSql.cs b/src/LightORM/ExpressionSql/ScopedExpressionCoreSql.cs index 68c99456..1cdae3a4 100644 --- a/src/LightORM/ExpressionSql/ScopedExpressionCoreSql.cs +++ b/src/LightORM/ExpressionSql/ScopedExpressionCoreSql.cs @@ -12,12 +12,17 @@ internal sealed class ScopedExpressionCoreSql(ExpressionSqlOptions options) : Ex private readonly ConcurrentDictionary connections = []; private TransientContext? current; public override SqlAdo Ado => current?.Ado ?? DefaultAdo; - + private DatabaseConnection GetConnection(string key) + { + var conn = connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection); + conn.KeepAlive = true; + return conn; + } public SqlAdo DefaultAdo { get { - var connection = connections.GetOrAdd(Options.DefaultDbKey, connectionFactory.GetDatabaseConnection); + var connection = GetConnection(Options.DefaultDbKey); if (useTrans) { connection.BeginTransaction(); @@ -33,7 +38,7 @@ ITransientContext IScopedExpressionContext.SwitchDatabase(string key) { return ctx; } - var connection = connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection); + var connection = GetConnection(key); if (useTrans) { connection.BeginTransaction(isolationLevel); @@ -48,6 +53,7 @@ public void Dispose() { foreach (var item in connections.Values) { + item.KeepAlive = false; if (item.State == AdoState.Active && item.UnderTransaction) { try @@ -90,13 +96,13 @@ public void RollbackAllTransaction() } } public void BeginTransaction(string key = "MainDb", IsolationLevel isolationLevel = IsolationLevel.Unspecified) - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).BeginTransaction(isolationLevel); + => GetConnection(key).BeginTransaction(isolationLevel); public void CommitTransaction(string key = "MainDb") - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).CommitTransaction(); + => GetConnection(key).CommitTransaction(); public void RollbackTransaction(string key = "MainDb") - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).RollbackTransaction(); + => GetConnection(key).RollbackTransaction(); #if NET8_0_OR_GREATER public async Task BeginAllTransactionAsync(IsolationLevel isolationLevel = IsolationLevel.Unspecified, CancellationToken cancellationToken = default) @@ -130,15 +136,15 @@ public async Task RollbackAllTransactionAsync(CancellationToken cancellationToke public Task BeginTransactionAsync(string key = "MainDb" , IsolationLevel isolationLevel = IsolationLevel.Unspecified , CancellationToken cancellationToken = default) - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).BeginTransactionAsync(isolationLevel, cancellationToken); + => GetConnection(key).BeginTransactionAsync(isolationLevel, cancellationToken); public Task CommitTransactionAsync(string key = "MainDb", CancellationToken cancellationToken = default) - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).CommitTransactionAsync(cancellationToken); + => GetConnection(key).CommitTransactionAsync(cancellationToken); public Task RollbackTransactionAsync(string key = "MainDb", CancellationToken cancellationToken = default) - => connections.GetOrAdd(key, connectionFactory.GetDatabaseConnection).RollbackTransactionAsync(cancellationToken); + => GetConnection(key).RollbackTransactionAsync(cancellationToken); #endif } diff --git a/src/LightORM/ExpressionSql/SingleScopedExpressionCoreSql.cs b/src/LightORM/ExpressionSql/SingleScopedExpressionCoreSql.cs index da0da7b1..9802044b 100644 --- a/src/LightORM/ExpressionSql/SingleScopedExpressionCoreSql.cs +++ b/src/LightORM/ExpressionSql/SingleScopedExpressionCoreSql.cs @@ -30,6 +30,7 @@ public async Task RollbackTransactionAsync(CancellationToken cancellationToken = public void Dispose() { + databaseConnection.KeepAlive = false; if (databaseConnection.State == AdoState.Active && databaseConnection.UnderTransaction) { try diff --git a/src/LightORM/Extension/BatchActionHelper.cs b/src/LightORM/Extension/BatchActionHelper.cs index 9212c6d3..f633361e 100644 --- a/src/LightORM/Extension/BatchActionHelper.cs +++ b/src/LightORM/Extension/BatchActionHelper.cs @@ -1,79 +1,81 @@ -namespace LightORM.Extension +namespace LightORM.Extension; + +internal static class BatchActionHelper { - internal static class BatchActionHelper + /// + /// 计算批次数量 + /// + /// 列数,对应参数个数 + /// 参数个数最大值 + /// 更新实体数量 + /// 每次更新的行数 + /// + private static int CalcBatchSize(int column, int limit, int dataCount, out int rows) { - /// - /// 计算批次数量 - /// - /// 列数,对应参数个数 - /// 参数个数最大值 - /// 更新实体数量 - /// 每次更新的行数 - /// - private static int CalcBatchSize(int column, int limit, int dataCount, out int rows) - { - rows = limit / column; - if (rows == 0) rows = 1; - var size = dataCount / rows; - if (size == 0) size = 1; + rows = limit / column; + if (rows == 0) rows = 1; + var size = dataCount / rows; + if (size == 0) size = 1; - if (size * rows < dataCount) - { - size++; - } - return size; + if (size * rows < dataCount) + { + size++; } - public static List GenBatchInfos(this ITableColumnInfo[] columns - , T[] datas - , IDatabaseAdapter database - , int limit = 2000 - , Dictionary? additionalParameters = null) + return size; + } + public static List GenBatchInfos(this ITableColumnInfo[] columns + , T[] datas + , IDatabaseAdapter database + , int limit = 2000 + , Dictionary? additionalParameters = null) + { + var list = new List(); + var verions = columns.Count(c => c.IsVersionColumn); + var size = CalcBatchSize(columns.Length + verions, limit, datas.Length, out var rows); + for (var i = 0; i < size; i++) { - var list = new List(); - var verions = columns.Count(c => c.IsVersionColumn); - var size = CalcBatchSize(columns.Length + verions, limit, datas.Length, out var rows); - for (var i = 0; i < size; i++) + var rowIndex = 0; + var batchList = datas.Skip(i * rows).Take(rows); + var pList = new List>(); + foreach (var obj in batchList) { - var rowIndex = 0; - var batchList = datas.Skip(i * rows).Take(rows); - var pList = new List>(); - foreach (var obj in batchList) + var row = new List(); + foreach (var col in columns) { - var row = new List(); - foreach (var col in columns) + var isStatic = GetValue(col, obj!, additionalParameters, out var val); + if (val is bool) { - var isStatic = GetValue(col, obj!, additionalParameters, out var val); - if (val is bool) - { - isStatic = true; - } + isStatic = true; + } - row.Add(new SimpleColumn(col, $"{col.PropertyName}_{rowIndex}", rowIndex, false, val, isStatic) - ); + row.Add(new SimpleColumn(col, $"{col.PropertyName}_{rowIndex}", rowIndex, false, val, isStatic) + ); - if (col.IsVersionColumn) - { - var newVersionValue = SqlBuilder.VersionPlus(val); - row.Add(new SimpleColumn(col, $"{col.PropertyName}_{rowIndex}_n", rowIndex, true, newVersionValue, isStatic)); - } + if (col.IsVersionColumn) + { + var newVersionValue = SqlBuilder.VersionPlus(val); + row.Add(new SimpleColumn(col, $"{col.PropertyName}_{rowIndex}_n", rowIndex, true, newVersionValue, isStatic)); } - rowIndex++; - pList.Add(row); } - - list.Add(new BatchSqlInfo(pList, i + 1)); + rowIndex++; + pList.Add(row); } - return list; - static bool GetValue(ITableColumnInfo col, object target, Dictionary? additionalParameters, out object? value) + list.Add(new BatchSqlInfo(pList, i + 1) { - if (additionalParameters != null && additionalParameters.TryGetValue(col.PropertyName, out value)) - { - return true; - } - value = col.GetValue(target); - return false; + SetCount = columns.Length + }); + } + return list; + + static bool GetValue(ITableColumnInfo col, object target, Dictionary? additionalParameters, out object? value) + { + if (additionalParameters != null && additionalParameters.TryGetValue(col.PropertyName, out value)) + { + return true; } + value = col.GetValue(target); + return false; } } } diff --git a/src/LightORM/Extension/SelectHandleExtensions.cs b/src/LightORM/Extension/SelectHandleExtensions.cs index ee610759..4b4f74d7 100644 --- a/src/LightORM/Extension/SelectHandleExtensions.cs +++ b/src/LightORM/Extension/SelectHandleExtensions.cs @@ -105,6 +105,7 @@ internal SelectProvider1 HandleSubQuery< TTemp>(string? alias = null) { select.SqlBuilder.IsSubQuery = true; + select.SqlBuilder.Depth += 1; var builder = SelectBuilder.GetSelectBuilder(); builder.QuoteIdentifiers = select.SqlBuilder.QuoteIdentifiers; var table = TableInfo.Create(); diff --git a/src/LightORM/Implements/BaseSqlMethodResolver.cs b/src/LightORM/Implements/BaseSqlMethodResolver.cs index 9468bc78..539f370f 100644 --- a/src/LightORM/Implements/BaseSqlMethodResolver.cs +++ b/src/LightORM/Implements/BaseSqlMethodResolver.cs @@ -394,6 +394,11 @@ public virtual void Coalesce(IExpressionResolver resolver, MethodCallExpression resolver.Visit(methodCall.Arguments[i]); resolver.Sql.Append(','); } + var type = fallbackValue.Type; + if (type == typeof(string)) + { + resolver.Sql.Append('N'); + } resolver.Visit(fallbackValue); resolver.Sql.Append(')'); } diff --git a/src/LightORM/Implements/CustomDatabaseAdapter.cs b/src/LightORM/Implements/CustomDatabaseAdapter.cs index d61edd66..e8bc0685 100644 --- a/src/LightORM/Implements/CustomDatabaseAdapter.cs +++ b/src/LightORM/Implements/CustomDatabaseAdapter.cs @@ -145,6 +145,40 @@ public virtual void HandleJsonParameter(JsonColumnParameterContext context) { } public virtual void DbCommandInit(DbCommand dbCommand) { } + public virtual void HandleSelectGroupBySegment(SelectContext context) + { + var sql = context.Sql; + var builder = context.Builder; + var ident = context.Ident; + if (builder.IsRollup) + { + // $"{ident}GROUP BY ROLLUP ({string.Join(", ", GroupBy)})" + sql.Append(ident).Append("GROUP BY ROLLUP (").Append(builder.GroupBy).AppendLine(")"); + } + else if (builder.IsCube) + { + // $"{ident}GROUP BY CUBE ({string.Join(", ", GroupBy)})" + sql.Append(ident).Append("GROUP BY CUBE (").Append(builder.GroupBy).AppendLine(")"); + } + else if (builder.GroupingSets.Count > 0) + { + sql.Append(ident).AppendLine("GROUP BY GROUPING SETS ("); + foreach (var set in builder.GroupingSets) + { + sql.Append(ident).Append(SqlBuilder.UNIT_IDENT) + .Append('(').Append(set).Append(')').AppendLine(","); + } + sql.RemoveLast(SqlBuilder.N.Length + 1); + sql.AppendLine(); + sql.Append(ident).AppendLine(")"); + } + else + { + // $"{ident}GROUP BY {string.Join(", ", GroupBy)}" + sql.Append(ident).Append("GROUP BY ").Append(builder.GroupBy).AppendLine(); + } + } + public virtual void HandleInsertOrUpdate(UpsertContext context) { throw new NotImplementedException(); @@ -220,9 +254,11 @@ public virtual void HandleBatchUpdate(BatchActionContext> co //sb.Append(GetTableName(database, MainTable, false)); sb.AppendTableName(database, builder.MainTable, false); sb.Append(" SET "); - for (int i = 0; i < updateColumns.Length; i++) + var currentBatchColumns = FilterAllNullColumns(batch, updateColumns); + //for (int i = 0; i < currentBatchColumns.Length; i++) + foreach(var col in currentBatchColumns) { - ITableColumnInfo? col = updateColumns[i]; + //ITableColumnInfo? col = currentBatchColumns[i]; if (col.IsPrimaryKey) continue; //sb.Append($"\n{database.AttachEmphasis(col.ColumnName)} = CASE "); sb.AppendEmphasis(col.ColumnName, database); @@ -282,7 +318,7 @@ public virtual void HandleBatchUpdate(BatchActionContext> co foreach (var i in item) { sb.AppendSimpleColumnParameter(i, database); - + sb.Append(','); } sb.RemoveLast(1); @@ -304,6 +340,30 @@ public virtual void HandleBatchUpdate(BatchActionContext> co builder.HandleSqlParameters(sb, database); batch.Sql = sb.ToString(); } + + static IEnumerable FilterAllNullColumns(BatchSqlInfo batch, ITableColumnInfo[] columns) + { + foreach (var item in columns) + { + var allNull = batch.RowParameters.All(row => + { + SimpleColumn c = row.First(r => + { + if (r.IsVersion) + { + return r.IsNewVersion && r.PropName == item.PropertyName; + } + return r.PropName == item.PropertyName; + }); + return c.Value is null; + }); + if (allNull) + { + continue; + } + yield return item; + } + } } public virtual void HandleBatchDelete(BatchActionContext> context) @@ -336,15 +396,22 @@ public virtual void HandleBatchDelete(BatchActionContext> co sb.Append('('); for (var i = 0; i < row.Count; i++) { - if (i > 0) + //if (i > 0) + //{ + // sb.Append(" AND "); + //} + var cell = row[i]; + if (cell.IsNewVersion) { - sb.Append(" AND "); + continue; } - sb.AppendEmphasis(row[i].ColumnName, database); + sb.AppendEmphasis(cell.ColumnName, database); sb.Append(" = "); - //sb.WithPrefix(row[i].ParameterName, database); - sb.AppendSimpleColumnParameter(row[i], database); + //sb.WithPrefix(cell.ParameterName, database); + sb.AppendSimpleColumnParameter(cell, database); + sb.Append(" AND "); } + sb.RemoveLast(5); sb.Append(')'); if (rowIndex < batch.RowParameters.Count - 1) sb.Append(" OR "); diff --git a/src/LightORM/Interfaces/IDatabaseAdapter.cs b/src/LightORM/Interfaces/IDatabaseAdapter.cs index 56943dd5..c713bbbe 100644 --- a/src/LightORM/Interfaces/IDatabaseAdapter.cs +++ b/src/LightORM/Interfaces/IDatabaseAdapter.cs @@ -22,7 +22,7 @@ public interface IDatabaseAdapter ///// 获取删除语句的模板,将提供两个参数,{0} 表示表名,{1} 表示别名 ///// //string DeleteTemplate { get; } - void Paging(ISelectSqlBuilder builder, StringBuilder sql); + internal void Paging(ISelectSqlBuilder builder, StringBuilder sql); void ReturnIdentitySql(StringBuilder sql); //void HandleBooleanValue(StringBuilder sql, bool value); string FormatBooleanValue(bool value); @@ -38,6 +38,8 @@ public interface IDatabaseAdapter void HandleJsonColumn(JsonColumnContext context); void HandleJsonParameter(JsonColumnParameterContext context); + internal void HandleSelectGroupBySegment(SelectContext context); + internal void HandleInsertOrUpdate(UpsertContext context); internal void HandleBatchInsert(BatchActionContext> context); diff --git a/src/LightORM/Interfaces/ISqlBuilder.cs b/src/LightORM/Interfaces/ISqlBuilder.cs index 5a280ed8..82a830bb 100644 --- a/src/LightORM/Interfaces/ISqlBuilder.cs +++ b/src/LightORM/Interfaces/ISqlBuilder.cs @@ -39,7 +39,7 @@ public interface ISqlBuilder string ToSqlString(IDatabaseAdapter database); } - public interface ISelectSqlBuilder : ISqlBuilder + internal interface ISelectSqlBuilder : ISqlBuilder { //int PageIndex { get; set; } //int PageSize { get; set; } @@ -48,5 +48,7 @@ public interface ISelectSqlBuilder : ISqlBuilder object? AdditionalValue { get; set; } string? GroupBy { get; set; } List OrderBy { get; set; } + HashSet OrderByMembers { get; set; } + HashSet SelectedMembers { get; set; } } } diff --git a/src/LightORM/Models/BatchSqlInfo.cs b/src/LightORM/Models/BatchSqlInfo.cs index e34be089..a0112815 100644 --- a/src/LightORM/Models/BatchSqlInfo.cs +++ b/src/LightORM/Models/BatchSqlInfo.cs @@ -18,6 +18,7 @@ internal class BatchSqlInfo(List> parameters, int index) { public int Index { get; set; } = index; public string? Sql { get; set; } + public int SetCount { get; set; } public List> RowParameters { get; set; } = parameters; } } diff --git a/src/LightORM/Models/ExpressionResolvedResult.cs b/src/LightORM/Models/ExpressionResolvedResult.cs index 0f9a4a6e..fbcfd1a8 100644 --- a/src/LightORM/Models/ExpressionResolvedResult.cs +++ b/src/LightORM/Models/ExpressionResolvedResult.cs @@ -8,6 +8,7 @@ public ExpressionResolvedResult(ExpressionResolver resolve) { SqlString = ReplaceConstantValue(resolve); Members = [.. resolve.ResolvedMembers]; + SelectedMembers = [.. resolve.SelectedMember]; MemberOfNavigateMember = resolve.MemberOfNavigateMember; UseNavigate = resolve.UseNavigate; NavigateDeep = resolve.NavigateDeep; @@ -40,7 +41,9 @@ private static string ReplaceConstantValue(ExpressionResolver resolve) /// /// 解析到的成员 /// - public IReadOnlyList? Members { get; } + public IReadOnlyList Members { get; } + public IReadOnlyList SelectedMembers { get; } + /// /// 是否使用了导航属性 /// diff --git a/src/LightORM/Models/JsonColumnContext.cs b/src/LightORM/Models/JsonColumnContext.cs index 6543bb37..c0436fe0 100644 --- a/src/LightORM/Models/JsonColumnContext.cs +++ b/src/LightORM/Models/JsonColumnContext.cs @@ -30,6 +30,11 @@ public enum ActionType public readonly record struct MapEntry(string Column, string Value); +internal readonly record struct SelectContext(SelectBuilder Builder + , StringBuilder Sql + , IDatabaseAdapter ScopedAdapter + , string Ident); + internal readonly record struct UpsertContext(SqlBuilder Builder, StringBuilder Sql, Dictionary ColumnValueMap, Dictionary Parameters, bool IgnoreWhenMap, IDatabaseAdapter ScopedAdapter); internal readonly record struct BatchActionContext(SqlBuilder Builder diff --git a/src/LightORM/Models/SqlExecuteContext.cs b/src/LightORM/Models/SqlExecuteContext.cs index 03f58961..748b6d17 100644 --- a/src/LightORM/Models/SqlExecuteContext.cs +++ b/src/LightORM/Models/SqlExecuteContext.cs @@ -15,7 +15,7 @@ public enum ExecuteMethod } public class SqlExecuteContext { - + public int? ConnectionId { get; set; } public string TraceId { get; } public ExecuteMethod ExecuteType { get; } public string? Sql { get; } @@ -29,6 +29,7 @@ public class SqlExecuteContext public SqlExecuteContext(SqlExecuteContext other) { + ConnectionId = other.ConnectionId; TraceId = other.TraceId; ExecuteType = other.ExecuteType; Sql = other.Sql; diff --git a/src/LightORM/Performances/ObjectPool.cs b/src/LightORM/Performances/ObjectPool.cs index 99d6f271..579d89ad 100644 --- a/src/LightORM/Performances/ObjectPool.cs +++ b/src/LightORM/Performances/ObjectPool.cs @@ -40,7 +40,7 @@ public virtual T Get() { if (ValidateObject(item)) { - Debug.WriteLine("借用了实例-快速对象"); + Debug.WriteLineIf(ShowObjectPoolDebugInfo,"借用了实例-快速对象"); return item; } item.Dispose(); @@ -49,7 +49,7 @@ public virtual T Get() while (_items.TryDequeue(out var ci)) { item = ci.Object; - Debug.WriteLine("借用了实例-队列"); + Debug.WriteLineIf(ShowObjectPoolDebugInfo, "借用了实例-队列"); Interlocked.Decrement(ref _numItems); if (ValidateObject(item)) return item; @@ -75,13 +75,13 @@ public virtual void Return(T item) // 快速路径尝试 if (_fastItem == null && Interlocked.CompareExchange(ref _fastItem, item, null) == null) { - Debug.WriteLine("归还了实例-快速对象"); + Debug.WriteLineIf(ShowObjectPoolDebugInfo, "归还了实例-快速对象"); return; } if (Interlocked.Increment(ref _numItems) <= _maxCapacity) { _items.Enqueue(new(item)); - Debug.WriteLine("归还了实例-队列"); + Debug.WriteLineIf(ShowObjectPoolDebugInfo, "归还了实例-队列"); return; } Interlocked.Decrement(ref _numItems); @@ -99,7 +99,7 @@ private void HealthCheckCallback(object? state) } private T CreateNewObject() { - Debug.WriteLine("创建了新的对象"); + Debug.WriteLineIf(ShowObjectPoolDebugInfo, "创建了新的对象"); return _createFunc(); } protected virtual void HealchCheck() diff --git a/src/LightORM/Providers/UpdateProvider.cs b/src/LightORM/Providers/UpdateProvider.cs index b22787a5..5fe7b313 100644 --- a/src/LightORM/Providers/UpdateProvider.cs +++ b/src/LightORM/Providers/UpdateProvider.cs @@ -74,6 +74,10 @@ public int Execute() } foreach (var item in sqlBuilder.BatchInfos!) { + if (item.SetCount == 0) + { + continue; + } effectRows += ado.ExecuteNonQuery(item.Sql!, item.ToDictionaryParameters()); } if (ado.Connection.UnderTransaction) @@ -94,6 +98,10 @@ public int Execute() } else { + if (sqlBuilder.SetCount == 0) + { + return 0; + } var dbParameters = sqlBuilder.DbParameters; return ado.ExecuteNonQuery(sql, dbParameters); } @@ -117,6 +125,10 @@ public async Task ExecuteAsync(CancellationToken cancellationToken = defaul } foreach (var item in sqlBuilder.BatchInfos!) { + if (item.SetCount == 0) + { + continue; + } effectRows += await ado.ExecuteNonQueryAsync(item.Sql!, item.ToDictionaryParameters(), cancellationToken: cancellationToken).ConfigureAwait(false); } if (ado.Connection.UnderTransaction) @@ -145,6 +157,10 @@ public async Task ExecuteAsync(CancellationToken cancellationToken = defaul } else { + if (sqlBuilder.SetCount == 0) + { + return 0; + } var dbParameters = sqlBuilder.DbParameters; return await ado.ExecuteNonQueryAsync(sql, dbParameters, cancellationToken: cancellationToken); } diff --git a/src/LightORM/Repository/DefaultRepository.cs b/src/LightORM/Repository/DefaultRepository.cs index 8ac0c30e..34fd5edb 100644 --- a/src/LightORM/Repository/DefaultRepository.cs +++ b/src/LightORM/Repository/DefaultRepository.cs @@ -177,8 +177,8 @@ private void Dispose(bool disposing) { if (disposing) { + context?.TryCommitTransaction(); context?.Dispose(); - context?.TryRollbackTransaction(); } disposedValue = true; diff --git a/src/LightORM/SqlExecutor/DatabaseConnection.cs b/src/LightORM/SqlExecutor/DatabaseConnection.cs index 378ae971..ae5f8f12 100644 --- a/src/LightORM/SqlExecutor/DatabaseConnection.cs +++ b/src/LightORM/SqlExecutor/DatabaseConnection.cs @@ -13,7 +13,7 @@ internal enum AdoState } public class DatabaseConnection : IDisposable { - private bool disposed; + //private bool disposed; public bool IsOccurException => State == AdoState.OccurException; internal AdoState State { get; private set; } public IDatabaseProvider Provider { get; } @@ -25,7 +25,7 @@ public class DatabaseConnection : IDisposable public int TransactionNestLevel { get; set; } public int Id => Connection.GetHashCode(); public bool IsExternal { get; set; } - + public bool KeepAlive { get; set; } internal DatabaseConnection(DbConnection connection , IDatabaseProvider provider , AdoInterceptor adoInterceptor @@ -50,7 +50,7 @@ public void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.Unsp { try { - ObjectDisposedException.ThrowIf(disposed, this); + //ObjectDisposedException.ThrowIf(disposed, this); if (Transaction is null) { if (Connection.State != ConnectionState.Open) @@ -71,6 +71,7 @@ public void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.Unsp } #endif } + State = AdoState.Active; } catch (Exception ex) { @@ -185,7 +186,7 @@ public async Task BeginTransactionAsync(IsolationLevel isolationLevel = Isolatio { try { - ObjectDisposedException.ThrowIf(disposed, this); + //ObjectDisposedException.ThrowIf(disposed, this); if (Transaction is null) { if (Connection.State != ConnectionState.Open) @@ -205,6 +206,7 @@ public async Task BeginTransactionAsync(IsolationLevel isolationLevel = Isolatio Transaction.Save($"savePoint{TransactionNestLevel}"); } } + State = AdoState.Active; } catch (Exception ex) { @@ -300,7 +302,7 @@ public async Task RollbackTransactionAsync(CancellationToken cancellationToken = State = AdoState.Rollback; Debug.WriteLineIf(ShowSqlExecutorDebugInfo, $"RollbackTranAsync: {Id} -> finished"); } - catch(Exception ex) + catch (Exception ex) { var ctx = new SqlExecuteExceptionContext(new SqlExecuteContext(ExecuteMethod.RollbackTransaction, null, null, typeof(object)), ex); Interceptor.NotifyException(ctx); @@ -316,8 +318,8 @@ public async Task RollbackTransactionAsync(CancellationToken cancellationToken = public void Dispose() { - if (disposed) - return; + //if (disposed) + // return; // 内部事务创建的事务上下文 if (!IsExternal) { @@ -327,13 +329,16 @@ public void Dispose() { Connection.Close(); } - var pool = ConnectionPool.Pools[Provider]; - pool.Return(Connection); + if (!KeepAlive) + { + var pool = ConnectionPool.Pools[Provider]; + pool.Return(Connection); + } } Transaction?.Dispose(); Transaction = null; } - disposed = true; + //disposed = true; GC.SuppressFinalize(this); } } diff --git a/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.AOT.cs b/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.AOT.cs index 746ae95a..b82d8c76 100644 --- a/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.AOT.cs +++ b/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.AOT.cs @@ -32,8 +32,12 @@ public ScalarValue ExecuteScalar(string commandText, CommandType commandType = C public DbDataReader ExecuteReader(string commandText, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null) => executor.ExecuteReader(commandText, NullDbParameter.Instance, commandType, behavior); - public MultipleResult QueryMultiple(string sql, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null) - => executor.QueryMultiple(sql, NullDbParameter.Instance, commandType, behavior); + public MultipleResult QueryMultiple(string[] sqls, Dictionary? parameters = null, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null) + { + parameters ??= []; + var sql = executor.Provider.DatabaseAdapter.HandleMultipleQuerySql(sqls, parameters); + return executor.QueryMultiple(sql, parameters, commandType, behavior); + } public DataSet ExecuteDataSet(string commandText, CommandType commandType = CommandType.Text) => executor.ExecuteDataSet(commandText, NullDbParameter.Instance, commandType); @@ -50,8 +54,12 @@ public Task ExecuteScalarAsync(string commandText, CommandType comm public Task ExecuteReaderAsync(string commandText, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null, CancellationToken cancellationToken = default) => executor.ExecuteReaderAsync(commandText, NullDbParameter.Instance, commandType, behavior, cancellationToken); - public Task QueryMultipleAsync(string commandText, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null, CancellationToken cancellationToken = default) - => executor.QueryMultipleAsync(commandText, NullDbParameter.Instance, commandType, behavior, cancellationToken); + public Task QueryMultipleAsync(string[] sqls, Dictionary? parameters = null, CommandType commandType = CommandType.Text, CommandBehavior? behavior = null, CancellationToken cancellationToken = default) + { + parameters ??= []; + var sql = executor.Provider.DatabaseAdapter.HandleMultipleQuerySql(sqls, parameters); + return executor.QueryMultipleAsync(sql, parameters, commandType, behavior, cancellationToken); + } public Task ExecuteDataSetAsync(string commandText, CommandType commandType = CommandType.Text, CancellationToken cancellationToken = default) => executor.ExecuteDataSetAsync(commandText, NullDbParameter.Instance, commandType, cancellationToken); diff --git a/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.cs b/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.cs index 35095587..4aa6556b 100644 --- a/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.cs +++ b/src/LightORM/SqlExecutor/Extensions/SqlExecutorExtensions.cs @@ -237,7 +237,6 @@ public static async IAsyncEnumerable QueryAsync< { await reader.CloseAsync(); } - reader?.Close(); } } @@ -276,7 +275,6 @@ public static async IAsyncEnumerable QueryAsync(this SqlAdo self { await reader.CloseAsync(); } - reader?.Close(); } } #endif diff --git a/src/LightORM/SqlExecutor/InternalDataReaderLight.cs b/src/LightORM/SqlExecutor/InternalDataReaderLight.cs index 6e6178d8..f256876e 100644 --- a/src/LightORM/SqlExecutor/InternalDataReaderLight.cs +++ b/src/LightORM/SqlExecutor/InternalDataReaderLight.cs @@ -85,7 +85,14 @@ public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int public override int GetOrdinal(string name) => dataReader.GetOrdinal(name); - public override string GetString(int ordinal) => dataReader.GetString(ordinal); + public override string GetString(int ordinal) + { + if (dataReader.IsDBNull(ordinal)) + { + return null!; + } + return dataReader.GetString(ordinal); + } public override object GetValue(int ordinal) => dataReader.GetValue(ordinal); diff --git a/src/LightORM/SqlExecutor/SqlAdo.cs b/src/LightORM/SqlExecutor/SqlAdo.cs index 4c6258d5..49aac782 100644 --- a/src/LightORM/SqlExecutor/SqlAdo.cs +++ b/src/LightORM/SqlExecutor/SqlAdo.cs @@ -54,6 +54,7 @@ private PrepareResult PrepareCommand(CommandType commandType, SqlExecuteContext { return new(null!, true); } + et.ConnectionId = Connection.Id; //DbLog?.Invoke(commandText, dbParameters); Interceptor.NotifyPrepareCommand(et); DbConnection conn = Connection.GetCurrentConnection(); @@ -79,6 +80,7 @@ private async Task PrepareCommandAsync(CommandType commandType, S return new(null!, true); } //DbLog?.Invoke(commandText, dbParameters); + et.ConnectionId = Connection.Id; Interceptor.NotifyPrepareCommand(et); DbConnection conn = Connection.GetCurrentConnection(); if (conn.State != ConnectionState.Open) diff --git a/src/LightORM/Utils/ExpressionResolver.cs b/src/LightORM/Utils/ExpressionResolver.cs index db0d7c95..5ca7670d 100644 --- a/src/LightORM/Utils/ExpressionResolver.cs +++ b/src/LightORM/Utils/ExpressionResolver.cs @@ -8,23 +8,22 @@ using System.Text; namespace LightORM; +internal readonly record struct SelectMap(string Column, string? Source); + internal static class ExpressionExtensions { - private readonly record struct CacheKey(SqlAction SqlAction, ulong Hash); + private readonly record struct CacheKey(SqlAction SqlAction, ulong Hash, int NestedLevel); private static readonly ConcurrentDictionary expressionResolvedResultCache = new(); public static ExpressionResolvedResult Resolve(this Expression? expression, SqlResolveOptions options, ResolveContext context) { - //resolve.Visit(expression); - //return new ExpressionResolvedResult(resolve); - //var resolve = new ExpressionResolver(options, context); bool enableCache = ExpressionSqlOptions.Instance.Value.EnableExpressionCache; ulong hash = 0; if (enableCache) { hash = ExpressionHasher.Default.ComputeHash64(expression); - Debug.WriteLineIf(ShowExpressionHashCodeDebugInfo, $"hashcocde: {hash}"); + Debug.WriteLineIf(ShowExpressionHashCodeDebugInfo, $"{expression} hashcocde: {hash}"); } - CacheKey key = new(options.SqlAction, hash); + CacheKey key = new(options.SqlAction, hash, context.Depth); if (enableCache && expressionResolvedResultCache.TryGetValue(key, out var result)) { //result.DbParameters @@ -111,6 +110,7 @@ internal class ExpressionResolver(SqlResolveOptions options, ResolveContext cont public StringBuilder Sql { get; set; } = new StringBuilder(128); public Stack Members { get; set; } = []; public List ResolvedMembers { get; set; } = []; + public List SelectedMember { get; set; } = []; public List? WindowFnPartials { get; set; } public bool UseNavigate { get; set; } public int NavigateDeep { get; set; } @@ -147,6 +147,7 @@ public ReadOnlyCollection? Parameters MemberInitExpression => Visit(VisitMemberInit((MemberInitExpression)expression)), MemberExpression => Visit(VisitMember((MemberExpression)expression)), ConstantExpression => Visit(VisitConstant((ConstantExpression)expression)), + _ => null }; } @@ -332,10 +333,16 @@ Indexer GetResolvedIndex(bool shouldReset = true) { var member = exp.Members![i]; var arg = exp.Arguments[i]; - + var curCount = ResolvedMembers.Count; + //ResolvedMembers.Add(exp.Members[i].Name); Visit(arg); if (Options.SqlType == SqlPartial.Select) + { + var source = ResolvedMembers.Count > curCount ? ResolvedMembers.LastOrDefault() : null; + SelectedMember.Add(new SelectMap(member.Name, source)); + } + if (Options.SqlType == SqlPartial.Select) { if (UseAs) { @@ -446,9 +453,13 @@ static MemberExpression SafeCreateProperty(Expression expression, string propert { continue; } - + var curCount = ResolvedMembers.Count; Visit(memberAssign.Expression); - + if (Options.SqlType == SqlPartial.Select) + { + var source = ResolvedMembers.Count > curCount ? ResolvedMembers.LastOrDefault() : null; + SelectedMember.Add(new SelectMap(memberAssign.Member.Name, source)); + } if (UseAs) { Sql.Append(AS_LITERAL); diff --git a/src/LightORM/Utils/Vistors/FlatGrouping.cs b/src/LightORM/Utils/Vistors/FlatGrouping.cs index d56f4073..74050803 100644 --- a/src/LightORM/Utils/Vistors/FlatGrouping.cs +++ b/src/LightORM/Utils/Vistors/FlatGrouping.cs @@ -150,7 +150,11 @@ protected override Expression VisitMember(MemberExpression node) { if (keySelector?.Body is MemberExpression m) { - return m; + var np = parameters.FirstOrDefault(p => p.Type == m.Expression?.Type); + if (np is not null) + { + return SafeCreateProperty(np, m.Member.Name); + } } else { @@ -171,6 +175,7 @@ protected override Expression VisitMember(MemberExpression node) return base.VisitMember(node); } + #if NET8_0_OR_GREATER [UnconditionalSuppressMessage("Trimming", "IL3050", Justification = "TypeSet或IExpSelectGrouping 的泛型参数和成员由用户显式编写,AOT 安全")] #endif diff --git a/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs b/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs index 7644ad93..a6f6ad81 100644 --- a/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs +++ b/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs @@ -1,4 +1,5 @@ -using LightORM.Extension; +using LightORM.Builder; +using LightORM.Extension; using LightORM.Implements; using LightORM.Interfaces; using LightORM.Models; @@ -16,6 +17,39 @@ public override void Paging(ISelectSqlBuilder builder, StringBuilder sql) { sql.AppendLine($"LIMIT {builder.Skip}, {builder.Take}"); } + + public override void HandleSelectGroupBySegment(SelectContext context) + { + var over8 = tableOptions.Version > new Version(8, 0); + if (over8) + { + base.HandleSelectGroupBySegment(context); + } + else + { + var sql = context.Sql; + var builder = context.Builder; + var ident = context.Ident; + if (builder.IsRollup) + { + // $"{ident}GROUP BY ROLLUP ({string.Join(", ", GroupBy)})" + sql.Append(ident).Append("GROUP BY (").Append(builder.GroupBy).AppendLine(") WITH ROLLUP"); + } + else if (builder.IsCube) + { + throw new NotSupportedException("MySQL 8.0 以下版本不支持 CUBE 分组"); + } + else if (builder.GroupingSets.Count > 0) + { + throw new NotSupportedException("MySQL 8.0 以下版本不支持 GROUPING SETS 分组"); + } + else + { + // $"{ident}GROUP BY {string.Join(", ", GroupBy)}" + sql.Append(ident).Append("GROUP BY ").Append(builder.GroupBy).AppendLine(); + } + } + } public override void ReturnIdentitySql(StringBuilder sql) => sql.Append("SELECT @@IDENTITY"); public override void HandleDateValue(StringBuilder sql, DateTime dateTime) diff --git a/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs b/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs index febd23de..cf08ec4d 100644 --- a/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs +++ b/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs @@ -5,4 +5,5 @@ public record MySqlTableOptions : TableOptions public string? Engine { get; set; } = "InnoDB"; public string? Charset { get; set; } = "utf8mb4"; public string? Collation { get; set; } = "utf8mb4_unicode_ci"; + public Version? Version { get; set; } } diff --git a/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs b/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs index 879f58e4..982fe250 100644 --- a/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs +++ b/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs @@ -23,17 +23,31 @@ public override void Paging(ISelectSqlBuilder builder, StringBuilder sql) else { var orderByString = ""; - var orderByType = ""; - if (builder.OrderBy.Count == 0) + var orderByType = (builder.AdditionalValue == null ? " ASC" : $" {builder.AdditionalValue}"); + if (builder.SelectedMembers.Count == 0) { - var col = builder.MainTable.TableEntityInfo.Columns.First(c => c.IsPrimaryKey); - orderByString = $"Sub.{col.ColumnName}"; - orderByType = " ASC"; + if (builder.OrderByMembers.Count > 0) + { + orderByString = string.Join(", ", builder.MainTable.TableEntityInfo.Columns.Where(c => builder.OrderByMembers.Contains(c.PropertyName)).Select(c => $"Sub.{this.AttachEmphasis(c.ColumnName)}")); + } + else + { + var col = builder.MainTable.TableEntityInfo.Columns.First(c => c.IsPrimaryKey); + orderByString = $"Sub.{col.ColumnName}"; + } } else { - orderByString = string.Join(",", builder.OrderBy.Select(s => s.Split('.')[1])); - orderByType = (builder.AdditionalValue == null ? "" : $" {builder.AdditionalValue}"); + if (builder.OrderByMembers.Count > 0) + { + var outerOrderColumns = builder.SelectedMembers.Where(s => s.Source is not null && builder.OrderByMembers.Contains(s.Source)).Select(s => s.Column); + orderByString = string.Join(", ", outerOrderColumns.Select(c => $"Sub.{this.AttachEmphasis(c)}")); + } + else + { + var c = builder.SelectedMembers.First().Column; + orderByString = $"Sub.{this.AttachEmphasis(c)}"; + } } sql.Insert(6, " TOP (100) PERCENT"); sql.Insert(0, $"SELECT ROW_NUMBER() OVER(ORDER BY {orderByString}{orderByType}) ROWNO, Sub.* FROM (\n"); diff --git a/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs b/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs index 84c5d9f0..057557fb 100644 --- a/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs +++ b/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs @@ -230,7 +230,12 @@ public override void NullThen(IExpressionResolver resolver, MethodCallExpression resolver.Sql.Append("ISNULL("); resolver.Visit(methodCall.Arguments[0]); resolver.Sql.Append(','); - resolver.Visit(methodCall.Arguments[1]); + var fallbackValue = methodCall.Arguments[1]; + if (fallbackValue.Type == typeof(string)) + { + resolver.Sql.Append('N'); + } + resolver.Visit(fallbackValue); resolver.Sql.Append(')'); } diff --git a/src/versions.props b/src/versions.props index d068da62..95ab8198 100644 --- a/src/versions.props +++ b/src/versions.props @@ -1,11 +1,11 @@  - 2026.09.02.1 + 2026.09.05.1 - 2026.09.02.1 + 2026.09.05.1 - 2026.09.02.1 + 2026.09.05.1 2026.08.31.1 @@ -18,9 +18,9 @@ 2026.08.31.1 - 2026.08.31.1 + 2026.09.05.1 - 2026.08.31.1 + 2026.09.05.1 2026.08.31.1 @@ -38,9 +38,9 @@ 2026.08.31.1 - 2026.08.31.1 + 2026.09.05.1 - 2026.08.31.1 + 2026.09.05.1 \ No newline at end of file diff --git a/test.db b/test.db index 0d1c7edc..9dbfe3c9 100644 Binary files a/test.db and b/test.db differ diff --git a/test/LightORMTest/Models/User.cs b/test/LightORMTest/Models/User.cs index 8e3b7616..727cd5ad 100644 --- a/test/LightORMTest/Models/User.cs +++ b/test/LightORMTest/Models/User.cs @@ -9,7 +9,7 @@ public enum SignType Svip = 2 } -[LightTable(Name = "USER", DatabaseKey = "Test")] +[LightTable(Name = "USER")] public class User { /// diff --git a/test/LightORMTest/ResultTest/ExecutionTest.AdoRepositoryCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.AdoRepositoryCases.cs new file mode 100644 index 00000000..03c31f8f --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.AdoRepositoryCases.cs @@ -0,0 +1,140 @@ +using LightORM.Extension; +using LightORM.Repository; +using Microsoft.Extensions.DependencyInjection; + +namespace LightORMTest.ResultTest; + +/// +/// ISqlExecutor/SqlAdo 原生执行、ILightOrmRepository 仓储、Scoped 上下文接口方法覆盖用例(基类) +/// 覆盖:ExecuteNonQuery / ExecuteScalar(Async) / ExecuteDataTable / ExecuteDataSet / +/// Query / QuerySingle(Async) / ExecuteResult / QueryMultiple / 仓储全套 / +/// Scoped 事务提交与回滚 +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Ado_Executor_Methods_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + + // ExecuteNonQuery + var nonQuery = Db.Ado.ExecuteNonQuery($""" + update {userTable} set user_name = {prefix}Name where user_id = {prefix}UserId + """, new { Name = "AdoUpdate", UserId = "test01" }); + Assert.AreEqual(1, nonQuery); + + // ExecuteScalar / ExecuteScalarAsync + int count = Db.Ado.ExecuteScalar($"select count(*) from {userTable}", new { }); + Assert.AreEqual(6, count); + int count2 = await Db.Ado.ExecuteScalarAsync($"select count(*) from {userTable}", new { }, cancellationToken: TestContext.CancellationToken); + Assert.AreEqual(6, count2); + + // ExecuteDataTable + var dt = Db.Ado.ExecuteDataTable($"select * from {userTable} where age > {prefix}Age", new { Age = 10 }); + Assert.AreEqual(4, dt.Rows.Count); + + // ExecuteDataSet + var ds = Db.Ado.ExecuteDataSet($"select * from {userTable}", new { }); + Assert.AreEqual(1, ds.Tables.Count); + Assert.AreEqual(6, ds.Tables[0].Rows.Count); + + // Query / QuerySingle / QuerySingleAsync + var q = Db.Ado.Query($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test01" }); + Assert.HasCount(1, q); + var single = Db.Ado.QuerySingle($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test02" }); + Assert.AreEqual("test02", single?.UserId); + var singleAsync = await Db.Ado.QuerySingleAsync($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test03" }, cancellationToken: TestContext.CancellationToken); + Assert.AreEqual("test03", singleAsync?.UserId); + + // Execute -> ExecuteResult.ToList / SingleAsync + var viaExecute = Db.Ado.Execute($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test04" }).ToList(); + Assert.HasCount(1, viaExecute); + var viaSingle = await Db.Ado.Execute($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test05" }).SingleAsync(TestContext.CancellationToken); + Assert.AreEqual("test05", viaSingle?.UserId); + } + + [TestMethod] + public async Task Ado_QueryMultiple_Test() + { + // 一条命令多结果集(注意:部分方言需开启多语句支持) + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + var roleTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("ROLE"); + using var multi = Db.Ado.QueryMultiple([$"select * from {userTable}", $"select * from {roleTable}"]); + var users = await multi.ReadListAsync(); + var roles = await multi.ReadListAsync(); + Assert.HasCount(6, users); + Assert.HasCount(3, roles); + } + + [TestMethod] + public async Task Repository_Methods_Test() + { + using var repo = Services.GetRequiredService>(); + + // GetOne / GetOneByKey(复合主键 UserId) + var u1 = repo.GetOne(x => x.UserId == "test01"); + Assert.IsNotNull(u1); + var u2 = repo.GetOneByKey("test01"); + Assert.IsNotNull(u2); + Assert.AreEqual(u1!.Id, u2!.Id); + + // Insert + SaveChanges + var inserted = repo.Insert(new User { UserId = "repo01", UserName = "Repo1", Password = "p", IsLock = false, Sign = SignType.None }); + Assert.IsGreaterThan(0, inserted); + Assert.IsTrue(repo.SaveChanges()); + + // InsertRange + SaveChanges + var insertedRange = repo.InsertRange([ + new User { UserId = "repo02", UserName = "Repo2", Password = "p", IsLock = false, Sign = SignType.None }, + new User { UserId = "repo03", UserName = "Repo3", Password = "p", IsLock = false, Sign = SignType.None }]); + Assert.AreEqual(2, insertedRange); + Assert.IsTrue(repo.SaveChanges()); + + // Update + SaveChanges + var toUpdate = await Db.Select().Where(x => x.UserId == "repo02").FirstAsync(TestContext.CancellationToken); + toUpdate!.UserName = "Repo2_Updated"; + Assert.IsGreaterThan(0, repo.Update(toUpdate)); + Assert.IsTrue(repo.SaveChanges()); + var updated = await Db.Select().Where(x => x.UserId == "repo02").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("Repo2_Updated", updated!.UserName); + + // Delete(entity) + DeleteRange + SaveChanges + var toDelete = await Db.Select().Where(x => x.UserId == "repo01").FirstAsync(TestContext.CancellationToken); + var toDeleteRange = await Db.Select().Where(x => x.UserId == "repo02" || x.UserId == "repo03").ToListAsync(TestContext.CancellationToken); + Assert.AreEqual(1, repo.Delete(toDelete!)); + Assert.AreEqual(2, repo.DeleteRange(toDeleteRange)); + Assert.IsTrue(repo.SaveChanges()); + var remain = await Db.Select().Where(x => x.UserId == "repo01" || x.UserId == "repo02" || x.UserId == "repo03").CountAsync(TestContext.CancellationToken); + Assert.AreEqual(0, remain); + + // 异步 InsertAsync / DeleteAsync + var insAsync = await repo.InsertAsync(new User { UserId = "repo04", UserName = "Repo4", Password = "p", IsLock = false, Sign = SignType.None }, TestContext.CancellationToken); + Assert.IsGreaterThan(0, insAsync); + Assert.AreEqual(1, await repo.DeleteAsync("repo04", cancellationToken: TestContext.CancellationToken)); + Assert.IsTrue(repo.SaveChanges()); + } + + [TestMethod] + public async Task Scoped_Context_Test() + { + // Scoped 上下文:独立事务,提交与回滚 + using var scoped = Db.CreateScoped(); + await scoped.Delete().Where(u => u.UserId == "scoped01").ExecuteAsync(TestContext.CancellationToken); + await scoped.Insert(new User { UserId = "scoped01", UserName = "Scoped1", Password = "p", IsLock = false, Sign = SignType.None, Version = 1 }) + .ExecuteAsync(TestContext.CancellationToken); + + await scoped.BeginTransactionAsync(); + await scoped.Update().Set(u => u.UserName == "ScopedTx").Where(u => u.UserId == "scoped01").ExecuteAsync(TestContext.CancellationToken); + await scoped.CommitTransactionAsync(); + var u = await scoped.Select().Where(x => x.UserId == "scoped01").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("ScopedTx", u?.UserName); + + // 回滚路径:修改后回滚,值保持 "ScopedTx" + await scoped.BeginTransactionAsync(); + await scoped.Update().Set(u => u.UserName == "ScopedRollback").Where(u => u.UserId == "scoped01").ExecuteAsync(TestContext.CancellationToken); + await scoped.RollbackTransactionAsync(); + u = await scoped.Select().Where(x => x.UserId == "scoped01").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("ScopedTx", u?.UserName); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.GroupAggregateCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.GroupAggregateCases.cs new file mode 100644 index 00000000..8892598f --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.GroupAggregateCases.cs @@ -0,0 +1,160 @@ +namespace LightORMTest.ResultTest; + +/// +/// IExpSelectGroup / IExpSelectGrouping 分组高级聚合接口方法覆盖用例(基类) +/// 覆盖:Sum / Sum(条件) / CountDistinct / Average / Round / Count / +/// Coalesce / NullThen / Join(GROUP_CONCAT) / 分组 OrderByDesc + Paging / +/// Rollup / Cube / 分组 First(Async) +/// 数据口径:Sales 共 28 条,7 个区域,各区域金额 +/// 华东=7500 华南=4800 华北=3700 华中=1550 西南=2200 东北=1350 西北=880(总额 21980) +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Group_Sum_Test() + { + // Sum(列) + Sum(条件, 列) + var list = await Db.Select() + .GroupBy(s => s.Region) + .ToListAsync(g => new + { + Region = g.Group, + Total = g.Sum(g.Tables.Amount), + BigTotal = g.Sum(g.Tables.Amount > 1000, g.Tables.Amount) + }, TestContext.CancellationToken); + + Assert.HasCount(7, list); + Assert.AreEqual(7500d, list.First(x => x.Region == "华东").Total, 0.001); + Assert.AreEqual(4800d, list.First(x => x.Region == "华南").Total, 0.001); + Assert.AreEqual(3700d, list.First(x => x.Region == "华北").Total, 0.001); + Assert.AreEqual(880d, list.First(x => x.Region == "西北").Total, 0.001); + + // 条件求和:仅统计 Amount > 1000 + Assert.AreEqual(6700d, list.First(x => x.Region == "华东").BigTotal, 0.001); // 排除 800 + Assert.AreEqual(3500d, list.First(x => x.Region == "华南").BigTotal, 0.001); // 排除 900/400 + Assert.AreEqual(1100d, list.First(x => x.Region == "华北").BigTotal, 0.001); // 排除 600/700/300 + Assert.AreEqual(0d, list.First(x => x.Region == "华中").BigTotal, 0.001); + } + + [TestMethod] + public async Task Group_CountDistinct_Test() + { + // 每个区域只有一种产品 + var list = await Db.Select() + .GroupBy(s => s.Region) + .ToListAsync(g => new { Region = g.Group, Products = g.CountDistinct(g.Tables.Product) }, TestContext.CancellationToken); + Assert.AreEqual(7, list.Count); + Assert.IsTrue(list.All(x => x.Products == 1)); + } + + [TestMethod] + public async Task Group_Round_Test() + { + // Round(平均值, 保留位数) + var list = await Db.Select() + .GroupBy(s => s.Region) + .ToListAsync(g => new + { + Region = g.Group, + Avg = g.Round(g.Average(g.Tables.Amount), 1), + Count = g.Count() + }, TestContext.CancellationToken); + + Assert.AreEqual(7, list.Count); + Assert.AreEqual(1500d, list.First(x => x.Region == "华东").Avg, 0.001); // 7500/5 + Assert.AreEqual(176d, list.First(x => x.Region == "西北").Avg, 0.001); // 880/5 + Assert.AreEqual(5, list.First(x => x.Region == "华东").Count); + Assert.AreEqual(3, list.First(x => x.Region == "华南").Count); + } + + [TestMethod] + public async Task Group_OrderBy_Paging_Test() + { + // 分组 OrderByDesc(聚合) + Paging + var list = await Db.Select() + .GroupBy(s => s.Region) + .OrderByDesc(g => g.Sum(g.Tables.Amount)) + .Paging(1, 3) + .ToListAsync(g => new { Region = g.Group, Total = g.Sum(g.Tables.Amount) }, TestContext.CancellationToken); + Assert.HasCount(3, list); + Assert.AreEqual("华东", list[0].Region); // 7500 + Assert.AreEqual("华南", list[1].Region); // 4800 + Assert.AreEqual("华北", list[2].Region); // 3700 + } + + [TestMethod] + public async Task Group_Rollup_Coalesce_Test() + { + // Rollup 产生汇总行,Coalesce 把 null 分组值替换为“合计” + var list = await Db.Select() + .GroupBy(s => s.Region) + .Rollup() + .ToListAsync(g => new { Region = g.Coalesce("合计", g.Group), Total = g.Count() }, TestContext.CancellationToken); + Assert.HasCount(8, list); // 7 区域 + 1 合计行 + Assert.IsTrue(list.Any(x => x.Region == "合计")); + Assert.IsTrue(list.Any(x => x.Region == "华东")); + } + + [TestMethod] + public async Task Group_Rollup_NullThen_Test() + { + // NullThen(列, 回退值):汇总行 Region 为 null 时回退为“合计” + var list = await Db.Select() + .GroupBy(s => s.Region) + .Rollup() + .ToListAsync(g => new { Region = g.NullThen(g.Group, "合计"), Total = g.Count() }, TestContext.CancellationToken); + Assert.HasCount(8, list); + Assert.IsTrue(list.Any(x => x.Region == "合计")); + } + + [TestMethod] + public async Task Group_Cube_Test() + { + // Cube(单列分组时等价于 Rollup,方言需支持 CUBE 语法) + var list = await Db.Select() + .GroupBy(s => s.Region) + .Cube() + .ToListAsync(g => new { Region = g.Coalesce("合计", g.Group), Total = g.Count() }, TestContext.CancellationToken); + Assert.IsGreaterThanOrEqualTo(7, list.Count); + Assert.IsTrue(list.Any(x => x.Region == "合计")); + } + + [TestMethod] + public async Task Group_Join_Test() + { + // Join(列) 分组内拼接字符串(GROUP_CONCAT / STRING_AGG / LISTAGG) + var list = await Db.Select() + .GroupBy(s => s.Region) + .ToListAsync(g => new { Region = g.Group, Provs = g.Join(g.Tables.Province).Separator(",").OrderBy(g.Tables.Province).Value() }, TestContext.CancellationToken); + Assert.HasCount(7, list); + var hd = list.First(x => x.Region == "华东"); + Assert.Contains("上海", hd.Provs); + Assert.Contains("福建", hd.Provs); + } + + [TestMethod] + public void Group_First_Test() + { + // 分组 First(exp) 同步:按金额升序第一个是 西北(880) + var first = Db.Select() + .GroupBy(s => s.Region) + .OrderBy(g => g.Sum(g.Tables.Amount)) + .First(g => new { Region = g.Group, Total = g.Sum(g.Tables.Amount) }); + Assert.IsNotNull(first); + Assert.AreEqual("西北", first!.Region); + Assert.AreEqual(880d, first.Total, 0.001); + } + + [TestMethod] + public async Task Group_FirstAsync_Test() + { + // 分组 FirstAsync(exp):按金额降序第一个是 华东(7500) + var first = await Db.Select() + .GroupBy(s => s.Region) + .OrderByDesc(g => g.Sum(g.Tables.Amount)) + .FirstAsync(g => new { Region = g.Group, Total = g.Sum(g.Tables.Amount) }, TestContext.CancellationToken); + Assert.IsNotNull(first); + Assert.AreEqual("华东", first!.Region); + Assert.AreEqual(7500d, first.Total, 0.001); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.NavigateAndJoinCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.NavigateAndJoinCases.cs new file mode 100644 index 00000000..f45a68ce --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.NavigateAndJoinCases.cs @@ -0,0 +1,109 @@ +namespace LightORMTest.ResultTest; + +/// +/// IExpSelect 导航加载(Include)与多来源 Join / WithTempQuery 接口方法覆盖用例(基类) +/// 覆盖:Include(引用导航) / Include(集合导航) / LeftJoin / RightJoin / +/// InnerJoin(string 表名) / InnerJoin(子查询) / InnerJoin(临时表) / WithTempQuery(多临时表) +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Select_Include_Profile_Test() + { + // 引用导航 Profile(一对一,User.UserId <-> UserProfile.UserId) + var result = await Db.Select() + .Include(u => u.Profile) + .Where(u => u.UserId == "test01") + .FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(result); + Assert.IsNotNull(result.Profile); + Assert.AreEqual("13800138001", result.Profile.Phone); + Assert.AreEqual("北京市朝阳区建国路1号", result.Profile.Address); + } + + [TestMethod] + public async Task Select_Include_MultiRole_Test() + { + // 集合导航 UserRoles(多对多),test03 拥有 Admin + SuperAdmin 两个角色 + var result = await Db.Select() + .Include(u => u.UserRoles) + .Where(u => u.UserId == "test03") + .FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(result); + Assert.IsNotNull(result.UserRoles); + Assert.AreEqual(2, result.UserRoles.Count()); + Assert.IsTrue(result.UserRoles.Any(r => r.RoleId == "Admin")); + Assert.IsTrue(result.UserRoles.Any(r => r.RoleId == "SuperAdmin")); + } + + [TestMethod] + public async Task Select_LeftJoin_Test() + { + // LeftJoin 泛型实体 + var list = await Db.Select() + .LeftJoin((u, ur) => u.UserId == ur.UserId) + .Where(u => u.UserId == "test01") + .ToListAsync((u, ur) => new { u.UserId, RoleId = ur.RoleId }, TestContext.CancellationToken); + Assert.HasCount(1, list); + Assert.AreEqual("Admin", list[0].RoleId); + } + + [TestMethod] + public async Task Select_RightJoin_Test() + { + // RightJoin(注意:个别方言 SQLite 需 3.39+ 才支持) + var list = await Db.Select() + .RightJoin((u, ur) => u.UserId == ur.UserId) + .ToListAsync((u, ur) => new { UserId = u.UserId, RoleId = ur.RoleId }, TestContext.CancellationToken); + Assert.HasCount(7, list); // 7 条 UserRole 全部保留 + } + + [TestMethod] + public async Task Select_Join_TableName_Test() + { + // InnerJoin(string tableName, ...) 按原始表名关联 + var list = await Db.Select() + .InnerJoin("USER_ROLE", (u, ur) => u.UserId == ur.UserId) + .Where(u => u.UserId == "test01") + .ToListAsync((u, ur) => new { u.UserId, RoleId = ur.RoleId }, TestContext.CancellationToken); + Assert.HasCount(1, list); + Assert.AreEqual("Admin", list[0].RoleId); + } + + [TestMethod] + public async Task Select_Join_SubQuery_Test() + { + // InnerJoin(IExpSelect 子查询, ...) + var list = await Db.Select() + .InnerJoin(Db.Select().Where(ur => ur.UserId == "test01"), (u, ur) => u.UserId == ur.UserId) + .ToListAsync((u, ur) => new { u.UserId, ur.RoleId }, TestContext.CancellationToken); + Assert.HasCount(1, list); + Assert.AreEqual("Admin", list[0].RoleId); + } + + [TestMethod] + public async Task Select_Join_Temp_Test() + { + // InnerJoin(IExpTemp 临时表, ...):只关联 Normal 角色的用户 + var temp = Db.Select().Where(ur => ur.RoleId == "Normal").AsTemp("normal_ur", ur => new { ur.UserId, ur.RoleId }); + var list = await Db.Select() + .InnerJoin(temp, (u, ur) => u.UserId == ur.UserId) + .ToListAsync((u, ur) => new { u.UserId, ur.RoleId }, TestContext.CancellationToken); + Assert.HasCount(3, list); // test04 / test05 / test06 + Assert.IsTrue(list.All(x => x.RoleId == "Normal")); + } + + [TestMethod] + public async Task Select_WithTempQuery_Two_Test() + { + // WithTempQuery 多临时表:年龄>10 且拥有 Admin 角色的用户(= test01) + var temp1 = Db.Select().Where(u => u.Age > 10).AsTemp("old_users", u => new { u.UserId }); + var temp2 = Db.Select().Where(r => r.RoleId == "Admin").AsTemp("admins", r => new { r.RoleId }); + var list = await Db.Select() + .WithTempQuery(temp1, temp2) + .Where((u, t1, t2) => u.UserId == t1.UserId && t2.RoleId == "Admin") + .ToListAsync((u, t1, t2) => u, TestContext.CancellationToken); + Assert.HasCount(4, list); + Assert.AreEqual("test01", list[0].UserId); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.SelectCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.SelectCases.cs new file mode 100644 index 00000000..9ca94a95 --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.SelectCases.cs @@ -0,0 +1,244 @@ +using LightORM.Extension; +using System.Data; + +namespace LightORMTest.ResultTest; + +/// +/// IExpSelect0 / IExpSelect 查询链接口方法覆盖用例(基类,各方言测试项目继承执行) +/// 覆盖:WhereIf / Where<TTable> / Paging / Skip / Take / Count(out) / Distinct / +/// ToDataTable / 聚合(同步+异步) / Union / UnionAll / AsSubQuery / AsTable / +/// AsTemp + WithTempQuery / FromTemp / FromQuery / 原生SQL / select-insert SQL 生成 +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Select_WhereIf_Test() + { + // 条件为 true 时生效 + var list = await Db.Select() + .WhereIf(true, u => u.Age > 10) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(4, list); + + // 条件为 false 时不生效 + list = await Db.Select() + .WhereIf(false, u => u.Age > 100) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(6, list); + } + + [TestMethod] + public async Task Select_WhereGenericTable_Test() + { + // join 后通过 Where 对关联表过滤 + var list = await Db.Select() + .InnerJoin((r, ur) => r.RoleId == ur.RoleId) + .Where(ur => ur.UserId == "test01") + .ToListAsync((r, ur) => r, TestContext.CancellationToken); + Assert.HasCount(1, list); + Assert.AreEqual("Admin", list[0].RoleId); + } + + [TestMethod] + public async Task Select_Paging_Test() + { + // Paging(pageIndex, pageSize),pageIndex 从 1 开始 + var page = await Db.Select() + .OrderBy(u => u.Age) + .Paging(2, 2) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(2, page); + Assert.AreEqual(11, page[0].Age); + Assert.AreEqual(12, page[1].Age); + + // Skip / Take + var skipTake = await Db.Select() + .OrderBy(u => u.Age) + .Skip(2).Take(3) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(3, skipTake); + Assert.AreEqual(11, skipTake[0].Age); + Assert.AreEqual(17, skipTake[2].Age); + + // Count(out total) 分页总数 + var paged = await Db.Select() + .Count(out var total) + .Paging(1, 2) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(2, paged); + Assert.AreEqual(6, total); + } + + [TestMethod] + public async Task Select_Distinct_Test() + { + // Distinct + 单列投影 -> SELECT DISTINCT REGION + var regions = Db.Select().Distinct().ToList(s => s.Region).ToList(); + Assert.HasCount(7, regions); + Assert.Contains("华东", regions); + Assert.Contains("西北", regions); + } + + [TestMethod] + public async Task Select_ToDataTable_Test() + { + var dt = Db.Select().Where(u => u.Age > 10).ToDataTable(); + Assert.HasCount(4, dt.Rows); + Assert.IsTrue(dt.Columns.Cast().Any(c => string.Equals(c.ColumnName, "USER_ID", StringComparison.OrdinalIgnoreCase))); + + var dt2 = await Db.Select().ToDataTableAsync(TestContext.CancellationToken); + Assert.HasCount(6, dt2.Rows); + } + + [TestMethod] + public void Select_Aggregate_Sync_Test() + { + // 同步聚合:Max / Min / Sum / Avg / Count / Any + Assert.AreEqual(21, Db.Select().Max(u => u.Age)); + Assert.AreEqual(8, Db.Select().Min(u => u.Age)); + Assert.AreEqual(78d, Db.Select().Sum(u => u.Age), 0.001); + Assert.AreEqual(13d, Db.Select().Avg(u => u.Age), 0.001); + Assert.AreEqual(6, Db.Select().Count()); + Assert.AreEqual(4, Db.Select().Where(u => u.Age > 10).Count()); + Assert.IsTrue(Db.Select().Any()); + Assert.IsFalse(Db.Select().Where(u => u.Age > 100).Any()); + } + + [TestMethod] + public async Task Select_Aggregate_Async_Test() + { + // 异步聚合:MaxAsync / MinAsync / SumAsync / AvgAsync / CountAsync / AnyAsync + Assert.AreEqual(21, await Db.Select().MaxAsync(u => u.Age, TestContext.CancellationToken)); + Assert.AreEqual(8, await Db.Select().MinAsync(u => u.Age, TestContext.CancellationToken)); + Assert.AreEqual(78d, await Db.Select().SumAsync(u => u.Age, TestContext.CancellationToken), 0.001); + Assert.AreEqual(13d, await Db.Select().AvgAsync(u => u.Age, TestContext.CancellationToken), 0.001); + Assert.AreEqual(6, await Db.Select().CountAsync(TestContext.CancellationToken)); + Assert.AreEqual(4, await Db.Select().Where(u => u.Age > 10).CountAsync(TestContext.CancellationToken)); + Assert.IsTrue(await Db.Select().AnyAsync(TestContext.CancellationToken)); + } + + [TestMethod] + public void Select_UnionAll_Test() + { + // Union 去重 + var list = Db.Select().Where(u => u.Age > 10) + .UnionAll(Db.Select().Where(u => u.Age > 15)) + .ToList(); + Assert.HasCount(6, list); + + // UnionAll 不去重 + var list2 = Db.Select().Where(u => u.UserId == "test01") + .UnionAll(Db.Select().Where(u => u.UserId == "test01")) + .ToList(); + Assert.HasCount(2, list2); + + // IExpressionContext.Union 多查询嵌套 + var list3 = Db.UnionAll( + Db.Select().Where(u => u.UserId == "test01"), + Db.Select().Where(u => u.UserId == "test02"), + Db.Select().Where(u => u.UserId == "test03")).ToList(); + Assert.HasCount(3, list3); + } + + [TestMethod] + public async Task Select_AsSubQuery_Test() + { + // AsSubQuery 包装为子查询后可继续排序/过滤 + var list = await Db.Select() + .Where(u => u.Age > 10) + .AsSubQuery() + .OrderBy(u => u.Age) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(4, list); + Assert.AreEqual(11, list[0].Age); + } + + [TestMethod] + public async Task Select_AsTable_Test() + { + // AsTable 投影为匿名表 + AsSubQuery 后继续 Where + var list = await Db.Select() + .Where(u => u.Age > 10) + .AsTable(u => new { u.UserId, u.Age }) + .AsSubQuery() + .Where(d => d.Age < 20) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(3, list); + Assert.IsTrue(list.All(d => d.Age < 20)); + } + + [TestMethod] + public async Task Select_AsTemp_WithTempQuery_Test() + { + // CTE:年龄>10 的用户集合,与 USER 表按 UserId 关联 + var temp = Db.Select().Where(u => u.Age > 10).AsTemp("old_users", u => new { u.UserId }); + var list = await Db.Select() + .WithTempQuery(temp) + .Where((u, t) => u.UserId == t.UserId) + .ToListAsync((u, t) => u, TestContext.CancellationToken); + Assert.HasCount(4, list); + } + + [TestMethod] + public async Task Select_FromTemp_Test() + { + var temp = Db.Select().Where(r => r.RoleId == "Admin").AsTemp("admins", r => new { r.RoleId }); + var roles = await Db.FromTemp(temp).ToListAsync(r => r.RoleId, TestContext.CancellationToken); + Assert.HasCount(1, roles); + Assert.AreEqual("Admin", roles[0]); + } + + [TestMethod] + public async Task Select_FromQuery_Test() + { + var list = await Db.FromQuery(Db.Select().Where(u => u.Age > 10)) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(4, list); + } + + [TestMethod] + public async Task Select_RawSql_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + + // WithParameters + Where(string) 共享参数 + var list = await Db.Select() + .WithParameters(new { Age = 10 }) + .Where($"age > {prefix}Age") + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(4, list); + + // Where(string, parameters) + var list2 = await Db.Select() + .Where($"age > {prefix}Age", new { Age = 15 }) + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(2, list2); + + // WhereIf(string) 条件控制 + var list3 = await Db.Select() + .WithParameters(new { Age = 10 }) + .WhereIf(true, $"age > {prefix}Age") + .WhereIf(false, $"age > 999") + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(4, list3); + + // 原生 OrderBy + var list4 = await Db.Select() + .OrderBy("age desc") + .ToListAsync(TestContext.CancellationToken); + Assert.HasCount(6, list4); + Assert.AreEqual(21, list4[0].Age); + } + + [TestMethod] + public void Select_Insert_Sql_Test() + { + // select-insert 链路的 SQL 生成覆盖(不执行,避免方言约束差异) + var sql = Db.Select() + .Where(u => u.UserId == "test01") + .SelectColumns(u => new { u.UserId, u.UserName }) + .Insert(u => new { u.UserId, u.UserName }) + .ToSql(); + StringAssert.StartsWith(sql, "INSERT INTO"); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.Trans.cs b/test/LightORMTest/ResultTest/ExecutionTest.Trans.cs index b95768d1..ddcef8bd 100644 --- a/test/LightORMTest/ResultTest/ExecutionTest.Trans.cs +++ b/test/LightORMTest/ResultTest/ExecutionTest.Trans.cs @@ -375,10 +375,11 @@ await scope.Update() Console.WriteLine($"捕获异常: {ex.Message}"); // 注意:这里没有调用 Rollback 或 Commit // 依赖 scope 的 Dispose 自动处理 + scope.RollbackTransaction(); } finally { - // 手动释放(会触发自动回滚) + // 手动释放(会触发自动提交) scope.Dispose(); } diff --git a/test/LightORMTest/ResultTest/ExecutionTest.WriteAdoRepoMoreCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.WriteAdoRepoMoreCases.cs new file mode 100644 index 00000000..49ea341e --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.WriteAdoRepoMoreCases.cs @@ -0,0 +1,212 @@ +using LightORM.Extension; +using LightORM.Repository; +using Microsoft.Extensions.DependencyInjection; + +namespace LightORMTest.ResultTest; + +/// +/// 写操作细节 / ISqlExecutor 原生执行补缺 / ILightOrmRepository 异步族接口方法覆盖用例(基类) +/// 覆盖:Insert(无实体, Set 逐列) / Insert ToSql/ToSqlWithParameters/Execute / +/// Update.UpdateColumns{TUpdate} / Update.WhereIf / Delete.FullDelete() 无参 / +/// Ado ExecuteReader / QueryAsync / ExecuteNonQueryAsync / ExecuteResult.Single(Async) / +/// QueryMultipleAsync + ReadFirst(Async) / 仓储 Table / ExpSelect / Delete(key) / 异步族 +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Insert_NoEntity_Test() + { + // 无实体插入:通过 Set 逐列指定值 + await Db.Insert() + .Set(u => u.UserId, "noe01") + .Set(u => u.UserName, "Noe") + .Set(u => u.Password, "p") + .Set(u => u.Sign, SignType.Vip) + .Set(u => u.IsLock, false) + .Set(u => u.Version, 1) + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "noe01").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("Noe", u.UserName); + Assert.AreEqual(SignType.Vip, u.Sign); + Assert.IsFalse(u.IsLock); + } + + [TestMethod] + public async Task Insert_ToSql_Execute_Test() + { + // ToSql / ToSqlWithParameters 仅生成 SQL,不执行 + var sql = Db.Insert(new User { UserId = "sy01", UserName = "Sy1", Password = "p", Sign = SignType.None, IsLock = false, Version = 1 }).ToSql(); + StringAssert.StartsWith(sql, "INSERT INTO"); + + var sqlWithParams = Db.Insert(new User { UserId = "sy01", UserName = "Sy1", Password = "p", Sign = SignType.None, IsLock = false, Version = 1 }).ToSqlWithParameters(); + StringAssert.StartsWith(sqlWithParams, "INSERT INTO"); + + // 同步 Execute + var e = Db.Insert(new User { UserId = "sy01", UserName = "Sy1", Password = "p", Sign = SignType.None, IsLock = false, Version = 1 }).Execute(); + Assert.AreEqual(1, e); + var u = await Db.Select().Where(x => x.UserId == "sy01").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("Sy1", u.UserName); + } + + [TestMethod] + public async Task Update_Columns_Test() + { + // UpdateColumns(exp) 只更新指定列 + var u = await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken); + u!.UserName = "ColsUpdated"; + u.Age = 99; + u.Sign = SignType.Vip; // 不在更新列中,应保持不变 + await Db.Update(u) + .UpdateColumns(x => new { x.UserName, x.Age }) + .ExecuteAsync(TestContext.CancellationToken); + + var reloaded = await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(reloaded); + Assert.AreEqual("ColsUpdated", reloaded.UserName); + Assert.AreEqual(99, reloaded.Age); + Assert.AreEqual(SignType.None, reloaded.Sign); // 未更新,保持初始值 + } + + [TestMethod] + public async Task Update_WhereIf_Test() + { + // Update 链路的 WhereIf + await Db.Update() + .Set(u => u.UserName == "WhereIf") + .WhereIf(true, u => u.UserId == "test01") + .WhereIf(false, u => u.UserId == "test02") + .ExecuteAsync(TestContext.CancellationToken); + var u1 = await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("WhereIf", u1?.UserName); + var u2 = await Db.Select().Where(x => x.UserId == "test02").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("Test2", u2?.UserName); + } + + [TestMethod] + public async Task Delete_FullDelete_NoTruncate_Test() + { + // FullDelete() 无参重载:DELETE 清空表 + await Db.Delete().FullDelete().ExecuteAsync(TestContext.CancellationToken); + var count = await Db.Select().CountAsync(TestContext.CancellationToken); + Assert.AreEqual(0, count); + } + + [TestMethod] + public async Task Ado_ExecuteReader_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + using var reader = Db.Ado.ExecuteReader($"select * from {userTable} where age > {prefix}Age", new { Age = 10 }); + int count = 0; + while (reader.Read()) + { + count++; + } + Assert.AreEqual(4, count); + } + + [TestMethod] + public async Task Ado_QueryAsync_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + int count = 0; + await foreach (var u in Db.Ado.QueryAsync($"select * from {userTable} where age > {prefix}Age", new { Age = 10 }, cancellationToken: TestContext.CancellationToken)) + { + Assert.IsNotNull(u.UserId); + count++; + } + Assert.AreEqual(4, count); + } + + [TestMethod] + public async Task Ado_ExecuteNonQueryAsync_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + var nonQuery = await Db.Ado.ExecuteNonQueryAsync($""" + update {userTable} set user_name = {prefix}Name where user_id = {prefix}UserId + """, new { Name = "AdoUpdAsync", UserId = "test01" }, cancellationToken: TestContext.CancellationToken); + Assert.AreEqual(1, nonQuery); + var u = await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken); + Assert.AreEqual("AdoUpdAsync", u?.UserName); + } + + [TestMethod] + public async Task Ado_ExecuteResult_Single_Test() + { + var prefix = CurrentDefaultProvider.DatabaseAdapter.Prefix; + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + var single = Db.Ado.Execute($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test01" }).Single(); + Assert.AreEqual("test01", single?.UserId); + var singleAsync = await Db.Ado.Execute($"select * from {userTable} where user_id = {prefix}Id", new { Id = "test02" }).SingleAsync(TestContext.CancellationToken); + Assert.AreEqual("test02", singleAsync?.UserId); + } + + [TestMethod] + public async Task Ado_QueryMultipleAsync_Test() + { + // 多结果集异步 + ReadFirst / ReadFirstAsync(注意:部分方言需开启多语句支持) + var userTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("USER"); + var roleTable = CurrentDefaultProvider.DatabaseAdapter.AttachEmphasis("ROLE"); + using var multi = await Db.Ado.QueryMultipleAsync([$"select * from {userTable}", $" select * from {roleTable}"], cancellationToken: TestContext.CancellationToken); + var firstUser = multi.ReadFirst(); + var firstRole = await multi.ReadFirstAsync(); + Assert.IsNotNull(firstUser); + Assert.IsNotNull(firstRole); + } + + [TestMethod] + public async Task Repository_Async_Operations_Test() + { + using var repo = Services.GetRequiredService>(); + + // ExpSelect 属性 + var viaExpSelect = repo.ExpSelect.Where(u => u.UserId == "test01").First(); + Assert.IsNotNull(viaExpSelect); + + // Table 属性(IQueryable) + var viaTable = repo.Table.Where(u => u.Age > 10).ToList(); + Assert.HasCount(4, viaTable); + + // InsertRangeAsync + SaveChanges + var inserted = await repo.InsertRangeAsync([ + new User { UserId = "repo11", UserName = "Repo11", Password = "p", IsLock = false, Sign = SignType.None,LastLogin = DateTime.Now }, + new User { UserId = "repo12", UserName = "Repo12", Password = "p", IsLock = false, Sign = SignType.None }], TestContext.CancellationToken); + Assert.AreEqual(2, inserted); + Assert.IsTrue(repo.SaveChanges()); + + // UpdateAsync + SaveChanges + var toUpdate = await Db.Select().Where(x => x.UserId == "repo11").FirstAsync(TestContext.CancellationToken); + toUpdate!.UserName = "Repo11_Updated"; + Assert.AreEqual(1, await repo.UpdateAsync(toUpdate, TestContext.CancellationToken)); + Assert.IsTrue(repo.SaveChanges()); + + // UpdateRange / UpdateRangeAsync + var range = await Db.Select().Where(x => x.UserId == "repo11" || x.UserId == "repo12").ToListAsync(TestContext.CancellationToken); + foreach (var u in range) u.Age = 55; + Assert.AreEqual(2, repo.UpdateRange(range)); + Assert.IsTrue(repo.SaveChanges()); + range = await Db.Select().Where(x => x.UserId == "repo11" || x.UserId == "repo12").ToListAsync(TestContext.CancellationToken); + foreach (var u in range) u.Age = 66; + Assert.AreEqual(2, await repo.UpdateRangeAsync(range, TestContext.CancellationToken)); + Assert.IsTrue(repo.SaveChanges()); + + // DeleteRangeAsync + Delete(主键) + SaveChanges + var toDelete = await Db.Select().Where(x => x.UserId == "repo11" || x.UserId == "repo12").ToListAsync(TestContext.CancellationToken); + Assert.AreEqual(2, await repo.DeleteRangeAsync(toDelete, TestContext.CancellationToken)); + Assert.IsTrue(repo.SaveChanges()); + Assert.AreEqual(1, repo.Delete("test01")); + Assert.IsTrue(repo.SaveChanges()); + var deleted = await Db.Select().Where(x => x.UserId == "repo11" || x.UserId == "repo12" || x.UserId == "test01").CountAsync(TestContext.CancellationToken); + Assert.AreEqual(0, deleted); + + // DeleteFullAsync + Assert.IsGreaterThanOrEqualTo(-1, await repo.DeleteFullAsync(truncate: true, cancellationToken: TestContext.CancellationToken)); + Assert.IsTrue(repo.SaveChanges()); + var remain = await Db.Select().CountAsync(TestContext.CancellationToken); + Assert.AreEqual(0, remain); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.WriteCases.cs b/test/LightORMTest/ResultTest/ExecutionTest.WriteCases.cs new file mode 100644 index 00000000..b08f8729 --- /dev/null +++ b/test/LightORMTest/ResultTest/ExecutionTest.WriteCases.cs @@ -0,0 +1,245 @@ +using System.Text; + +namespace LightORMTest.ResultTest; + +/// +/// IExpInsert / IExpUpdate / IExpDelete / IExpSelectGroup 写操作与分组接口方法覆盖用例(基类) +/// 覆盖:InsertColumns / IgnoreColumns / Set / SetIf / InsertByName / InsertByNames / +/// ReturnIdentity / UpdateByName / UpdateByNames / UpdateIgnoreColumns / SetNull / +/// SetNullIf / WithVersion / Delete.WhereIf / FullDelete(truncate) / 分组 Having / Rollup +/// +public partial class ExecutionTest +{ + [TestMethod] + public async Task Insert_Columns_Test() + { + // InsertColumns 仅插入指定列 + await Db.Insert(new User { UserId = "ins01", UserName = "Ins1", Password = "p", Age = 20, Sign = SignType.Vip, IsLock = false, Version = 1 }) + .InsertColumns(u => new { u.UserId, u.UserName, u.Password, u.Age, u.Sign, u.IsLock, u.Version }) + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "ins01").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("Ins1", u.UserName); + Assert.AreEqual(20, u.Age); + Assert.AreEqual(SignType.Vip, u.Sign); + } + + [TestMethod] + public async Task Insert_IgnoreColumns_Test() + { + // IgnoreColumns 忽略指定列(Avator 不入库) + var user = new User { UserId = "ins02", UserName = "Ins2", Password = "p", Age = 22, Sign = SignType.None, IsLock = false, Version = 1, Avator = Encoding.UTF8.GetBytes("ins02") }; + await Db.Insert(user) + .IgnoreColumns(u => new { u.Avator }) + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "ins02").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual(22, u.Age); + } + + [TestMethod] + public async Task Insert_Set_SetIf_Test() + { + // Set 覆盖字段值,SetIf 按条件决定是否覆盖 + await Db.Insert(new User { UserId = "ins03", UserName = "Ins3", Password = "p", Age = 1, Sign = SignType.None, IsLock = false, Version = 1 }) + .Set(u => u.Age, 33) + .SetIf(true, u => u.UserName, "SetIfApplied") + .SetIf(false, u => u.UserName, "SetIfIgnored") + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "ins03").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual(33, u.Age); + Assert.AreEqual("SetIfApplied", u.UserName); + } + + [TestMethod] + public async Task Insert_ByName_Test() + { + // InsertByName 按属性名指定插入列与值 + await Db.Insert(new User { UserId = "ins04", UserName = "Ins4", Password = "p", Sign = SignType.None, IsLock = false, Version = 1 }) + .InsertByName(nameof(User.UserName), "ByName") + .InsertByName(nameof(User.Password), "p") + .InsertByName(nameof(User.Sign), SignType.Vip) + .InsertByName(nameof(User.IsLock), false) + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "ins04").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("ByName", u.UserName); + Assert.AreEqual(SignType.Vip, u.Sign); + } + + [TestMethod] + public async Task Insert_ByNames_Test() + { + // InsertByNames 批量指定列名与值 + await Db.Insert(new User { UserId = "ins05", UserName = "x", Password = "x", Sign = SignType.None, IsLock = false, Version = 1 }) + .InsertByNames([nameof(User.UserName), nameof(User.Password), nameof(User.Sign), nameof(User.IsLock)], + ["ByNames", "p", SignType.Svip, true]) + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "ins05").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("ByNames", u.UserName); + Assert.AreEqual(SignType.Svip, u.Sign); + } + + //[TestMethod] + //public async Task Insert_ReturnIdentity_Test() + //{ + // // ReturnIdentity 自增主键回写 + // var id = await Db.Insert(new User { UserId = "ins06", UserName = "Ins6", Password = "p", Sign = SignType.None, IsLock = false, Version = 1 }) + // .ReturnIdentity() + // .ExecuteAsync(TestContext.CancellationToken); + // Assert.IsGreaterThanOrEqualTo(0, id); + // var u = await Db.Select().Where(x => x.UserId == "ins06").FirstAsync(TestContext.CancellationToken); + // Assert.IsNotNull(u); + //} + + [TestMethod] + public async Task Update_ByName_Test() + { + await Db.Update() + .UpdateByName(nameof(User.UserName), "ByNameUpdated") + .Where(u => u.UserId == "test01") + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("ByNameUpdated", u.UserName); + } + + [TestMethod] + public async Task Update_ByNames_Test() + { + await Db.Update() + .UpdateByNames([nameof(User.UserName), nameof(User.Age)], ["ByNamesUpdated", 99]) + .Where(u => u.UserId == "test02") + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "test02").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("ByNamesUpdated", u.UserName); + Assert.AreEqual(99, u.Age); + } + + [TestMethod] + public async Task Update_IgnoreColumns_Test() + { + // 更新实体时忽略 Age 列 + var u = await Db.Select().Where(x => x.UserId == "test03").FirstAsync(TestContext.CancellationToken); + u!.UserName = "IgnoredCol"; + u.Age = 77; + await Db.Update(u) + .IgnoreColumns(x => new { x.Age }) + .ExecuteAsync(TestContext.CancellationToken); + var updated = await Db.Select().Where(x => x.UserId == "test03").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(updated); + Assert.AreEqual("IgnoredCol", updated.UserName); + Assert.AreEqual(8, updated.Age); // Age 被忽略,保持原值 + } + + [TestMethod] + public async Task Update_SetNull_SetNullIf_Test() + { + // SetNull 将列置 NULL + await Db.Update() + .SetNull(u => u.Age) + .Where(u => u.UserId == "test04") + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "test04").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.IsNull(u.Age); + + // SetNullIf(true) 生效 + await Db.Update() + .SetNullIf(true, u => u.LastLogin) + .Where(u => u.UserId == "test04") + .ExecuteAsync(TestContext.CancellationToken); + + // SetNullIf(false) 不生效,Age 仍为 NULL + await Db.Update() + .SetNullIf(false, u => u.Age) + .Where(u => u.UserId == "test04") + .ExecuteAsync(TestContext.CancellationToken); + u = await Db.Select().Where(x => x.UserId == "test04").FirstAsync(TestContext.CancellationToken); + Assert.IsNull(u!.Age); + } + + [TestMethod] + public async Task Update_SetIf_Test() + { + await Db.Update() + .SetIf(true, u => u.UserName, "SetIfTrue") + .Where(u => u.UserId == "test05") + .ExecuteAsync(TestContext.CancellationToken); + await Db.Update() + .SetIf(false, u => u.UserName, "SetIfFalse") + .Where(u => u.UserId == "test05") + .ExecuteAsync(TestContext.CancellationToken); + var u = await Db.Select().Where(x => x.UserId == "test05").FirstAsync(TestContext.CancellationToken); + Assert.IsNotNull(u); + Assert.AreEqual("SetIfTrue", u.UserName); + } + + [TestMethod] + public async Task Update_WithVersion_Conflict_Test() + { + // 版本不匹配 -> 0 行 + var rows = await Db.Update() + .Set(u => u.UserName == "v2") + .WithVersion(u => u.Version, 999) + .Where(u => u.UserId == "test01") + .ExecuteAsync(TestContext.CancellationToken); + Assert.AreEqual(0, rows); + + // 版本匹配(初始化数据 Version=0)-> 1 行 + rows = await Db.Update() + .Set(u => u.UserName == "v2") + .WithVersion(u => u.Version, 0) + .Where(u => u.UserId == "test01") + .ExecuteAsync(TestContext.CancellationToken); + Assert.AreEqual(1, rows); + } + + [TestMethod] + public async Task Delete_WhereIf_Test() + { + var dc = await Db.Delete() + .WhereIf(true, u => u.UserId == "test01") + .WhereIf(false, u => u.UserId == "test02") + .ExecuteAsync(TestContext.CancellationToken); + Assert.AreEqual(1, dc); + Assert.IsNull(await Db.Select().Where(x => x.UserId == "test01").FirstAsync(TestContext.CancellationToken)); + Assert.IsNotNull(await Db.Select().Where(x => x.UserId == "test02").FirstAsync(TestContext.CancellationToken)); + } + + [TestMethod] + public async Task Delete_FullDelete_Test() + { + // FullDelete(truncate: true) 清空表 + await Db.Delete().FullDelete(truncate: true).ExecuteAsync(TestContext.CancellationToken); + var count = await Db.Select().CountAsync(TestContext.CancellationToken); + Assert.AreEqual(0, count); + } + + [TestMethod] + public async Task Group_Having_Test() + { + // 分组 + Having + 分组聚合投影 + var list = await Db.Select() + .GroupBy(s => s.Region) + .Having(g => g.Count() > 1) + .ToListAsync(g => new { Region = g.Group, Total = g.Count() }, TestContext.CancellationToken); + Assert.HasCount(7, list); + Assert.IsTrue(list.All(x => x.Total > 1)); + } + + [TestMethod] + public async Task Group_Rollup_Test() + { + // Rollup 分组汇总,额外产生 Region 为 null 的合计行 + var list = await Db.Select() + .GroupBy(s => s.Region) + .Rollup() + .ToListAsync(g => new { Region = g.Group, Total = g.Count() }, TestContext.CancellationToken); + Assert.IsGreaterThanOrEqualTo(7, list.Count); + Assert.IsTrue(list.Any(x => x.Region == null)); + } +} diff --git a/test/LightORMTest/ResultTest/ExecutionTest.cs b/test/LightORMTest/ResultTest/ExecutionTest.cs index 9a54e921..554d7dde 100644 --- a/test/LightORMTest/ResultTest/ExecutionTest.cs +++ b/test/LightORMTest/ResultTest/ExecutionTest.cs @@ -264,7 +264,7 @@ public async Task DeleteTest() Assert.AreEqual(1, dc); dc = await Db.Delete().Where(u => u.UserRoles.Any(ur => ur.RoleId == "Admin")).ExecuteAsync(TestContext.CancellationToken); - Assert.AreEqual(2, dc); + Assert.AreEqual(1, dc); var p = "13800138006"; dc = await Db.Delete().Where(u => u.Profile.Phone == p).ExecuteAsync(TestContext.CancellationToken); Assert.AreEqual(1, dc); diff --git a/test/LightORMTest/TestBase.cs b/test/LightORMTest/TestBase.cs index a0bdd5b6..a9f8a883 100644 --- a/test/LightORMTest/TestBase.cs +++ b/test/LightORMTest/TestBase.cs @@ -63,7 +63,7 @@ public override void AfterExecute(SqlExecuteContext context) Debug.WriteLine($""" - {context.TraceId} + {context.TraceId}[{context.ConnectionId}]: SQL: {context.Sql} =============== @@ -95,7 +95,7 @@ public override void BeforeExecute(SqlExecuteContext context) public override void OnException(SqlExecuteExceptionContext context) { - Debug.WriteLine($"{context.TraceId}:{context.Exception.Message}"); + Debug.WriteLine($"{context.TraceId}[{context.ConnectionId}]:{context.Exception.Message}"); Debug.WriteLine(context.Sql); Debug.WriteLine("====================================="); Debug.WriteLine("参数:");