diff --git a/.workbuddy/memory/2026-09-17.md b/.workbuddy/memory/2026-09-17.md index 3671b1d2..22fd0ac6 100644 --- a/.workbuddy/memory/2026-09-17.md +++ b/.workbuddy/memory/2026-09-17.md @@ -230,5 +230,562 @@ Expression CreateCustomEntity(Type targetType) ### 环境 - 六台容器全部在线(此前失败是实例未起):`dm8` 5236、`kes` 54321、`oracle21xe` 1521、`mysql` 3306、`pgsql` 5432、`mssql` 1433。 +## 方言版本开关自动探测:现状梳理与方案设计(未动代码) +需求:去掉手动设置版本(SqlServer 枚举 / `MySqlTableOptions.Version`),改为运行期自动查库版本并按版本选 SQL 写法。 + +**现状事实** +- 版本在**构造期烘焙**:`SqlServerProvider.Create(SqlServerVersion, ...)` → 同时注入 `SqlServerMethodResolver(version)` 与 `CustomSqlServerAdapter(version, ...)`。 +- 全部版本分支只有 6 处:SqlServer `Paging`(OFFSET-FETCH vs ROW_NUMBER)、`MethodResolver.Trim`(2017+ TRIM)、`MethodResolver.Value`(STRING_AGG)、MySQL `HandleSelectGroupBySegment`(8.0 ROLLUP/CUBE/GROUPING SETS)、Oracle `OverVersion`(自增列 DDL)、Dameng/SQLite `JSONBackend`(JSON_* vs JSONB_*)。 +- 同性质的手写开关分散在三种位置:provider 参数 / `XxxTableOptions` 属性 / 基类 `TableOptions`。 +- **P0 前置缺陷**:`Utils/ExpressionResolver.cs` 的 `expressionResolvedResultCache` 是 static,key = `(SqlAction, Hash, NestedLevel)`,**无方言/版本维度** → 同进程两个不同版本的同类 provider 会串味(今天就存在,一引入运行期探测会立刻显性化)。 +- 同一 DbBaseType 存在多个 adapter 实例:`ExpressionSqlOptions.customDatabases` 只留第一个注册的;provider 自己另有一个;MySQL 还有 `CustomMySqlAdapter.Instance`。 +- 离线场景:`test/**/SqlGenerate/*` 用例只 `Console.WriteLine`,**不连库**;且 `ToSql()` 是公开 API,本就要求无连接可用。 + +**时机结论(关键)** +- `InsertProvider.Execute()` → `sqlBuilder.ToSqlString(Database)` → `ado.ExecuteNonQueryAsync(sql,...)`:**SQL 在连接打开前就定稿**。`ToSql()` 更是完全无连接。 +- ⇒ 任何"从业务连接读 `DbConnection.ServerVersion`"的方案(含挂在 `conn.Open()` 上)只能保证"后续语句",首语句与纯生成场景必然错档 → **已废弃**。 +- 修正设计:探测与业务连接**解耦**。触发点 = 方言第一次**真正读取某个能力位**时(SQL 构建期);通道 = 独立短超时连接 `Open()` 一次(`ServerVersion` 无需发查询);结果按 (方言, 连接串) 缓存 + Single-flight;失败**不抛**,退保守基线并负缓存。 +- 另一条要点:能力读取必须**下沉到具体分支内部**(如 MySQL 只在 `IsRollup/IsCube/GroupingSets` 为真时才求值),否则每次 select 都会触发探测。这样普通 CRUD 零探测成本。 +- 基线档取向改为**保守**(正确性优先):SqlServer → 旧式 ROW_NUMBER 分页、`LTRIM(RTRIM())`;MySQL → `WITH ROLLUP`。探测成功即升级为精确档;无库/无权限/`ServerVersion` 未实现时只损失新语法,不产生非法 SQL。 +- 新增能力不必改 `IDatabaseAdapter`(会破坏第三方实现):复用已有 `Builder/AdapterCapability.TryGet` 穿透 `ScopedDatabaseAdapter` 探能力接口。 +- 模型建议:`[Flags] DbFeatures` + `DbCapabilityProfile(Vendor, Version, Features, Source=Explicit|Probed|Assumed, Signature)`;`IDbVersionDetector.Detect(DbConnection)` 每方言一个。MariaDB 10.x 版本号不能直接与 MySQL 8.0 比较,须先判厂商。 +- 待实测:各方言 `DbConnection.ServerVersion` 是否可用/格式/异常(重点 Dameng 的 `DmConnection` 可能 `NotImplementedException`、net462 的 `System.Data.SqlClient`、KingbaseES 版本串解析)。 + +## 阶段 0 实测完成 + 探测机制落地(Oracle 为参考实现) +环境提醒:六台容器曾**集体退出**(137/143,机器/桌面重启),`docker start dm8 kes oracle21xe mysql pgsql mssql` 后需等约 50s 才全部可连。 + +**`DbConnection.ServerVersion` 实测(探针工程 `%TEMP%\dbver-probe`,引用 7 个 provider 项目,用 `provider.DbProviderFactory` 建连)** + +| 方言 | `ServerVersion`(Open 后) | 格式 | Open 耗时 | 默认连接超时 | +|---|---|---|---|---| +| SqlServer | `16.00.4045` | 4 段(第 2 段补零) | 85ms | **15s** | +| MySql | `5.7.44` | 3 段 | 71ms | ~4.1s | +| PostgreSQL | `16.4 (Debian 16.4-1.pgdg120+1)` | **带后缀**,另有 `PostgreSqlVersion`=16.4 | 111ms | ~4.1s | +| KingbaseES | `12.1` | 2 段(**是兼容 PG 版本号**,产品版本要从 `SELECT version()` 得 `V009R001C010`);另有 `KingbaseESVersion` | 207ms | ~4.1s | +| Oracle | `21.3.0.0.0` | **5 段** | 230ms | ~4.1s | +| Dameng | `8.1.4.6` | 4 段 | 22ms | ~2s | +| Sqlite | `3.46.1` | 3 段,**Open 前即可读** | 0~14ms | — | + +- **Open 之前读 `ServerVersion` 一律抛 `InvalidOperationException`**(SQLite 除外)→ 必须先 Open。 +- **`System.Version` 只接受 2~4 段**:Oracle 的 5 段版本号会让 `Version.TryParse` 失败并**静默退化**成基线;正则必须限 `\d+(?:\.\d+){0,3}`。 +- **超时压制是必须的**:默认 4~15s,探测失败会拖住构建期。各方言键名不同(SqlServer/MySql/Oracle 认 `Connection Timeout`、Npgsql/Kdbndp 只认 `Timeout`、Dameng 只认 `Connect Timeout`),但**类型化 builder 对不认识的键一律抛异常**(ArgumentException / NotSupportedException)→ 按候选键依次试探、取第一个被接受即可,无需方言表。 +- **SQLite 不能走 Open 探测**:连接串指向不存在的文件时 Open 会**建出一个空库文件**;它未 Open 即可读版本,故 `openBeforeRead:false`。 + +**已实现(编译 0 警告,`net462;net8.0;net10.0` 全过)** +- `src/LightORM/Models/DbCapability.cs`:`DbFeatures`(**按方言划段**的能力位)、`CapabilitySource`(Explicit/Probed/Assumed)、`DbCapabilityProfile`(含 `Signature` 供表达式缓存键用)。 +- `src/LightORM/Interfaces/IDbCapabilitySource.cs`:**独立接口而非加 `IDatabaseAdapter` 成员**(避免破坏第三方实现),用 `AdapterCapability.TryGet` 探测。 +- `src/LightORM/Implements/DbCapabilityHandle.cs`:构造期 `Start()` 起后台探测;`Baseline()` 不探测;`Override()` 显式覆盖优先。要点:① 探测任务**永不 fault**(失败返 Assumed 基线);② **读取侧只等首次尝试**(≤一个连接超时),失败重试放后台并自愈(`ProbeState.Resolved`,同连接串的句柄共享)——实测连不上时首个读取从 5055ms 降到 2026ms;③ 单飞用 `ConcurrentDictionary>`;④ `mapFeatures(Version?, raw)` 同时给原始串(MariaDB 10.x 不能与 MySQL 8.0 直接比、KES 报兼容版本号)。 +- `OracleProvider` / `CustomOracleAdapter` 接入(adapter 实现 `IDbCapabilitySource`);静态 `CustomOracleAdapter.Instance` 用 `Baseline` 避免 IO。 + +**验证(7 项全过)**:构造 170ms 无 IO(探测后台跑);首读 253ms 得 `Oracle 21.3.0.0 [Probed] {OracleIdentityColumn, OracleJsonNativeType}`;二次读 0ms;3 个同串 provider 共享同一档案;连不上→Assumed 且不抛;连不上时 `ToSql` 仍可用;显式覆盖生效。 + +**既存失败(与本改动无关,已交叉验证)**:Oracle / PostgreSQL 的 `SqlGenerate` 过滤下各有同样 5 个失败(`Select_Navigate_Where_Single`、`TestArrayAccess_List`、`TestRowNumberWindowFunc`、`TestSelectOneTable`、`UpdateByName2`),栈在 `Utils/ResolveHelper.CreateGetter` 的 `Expression.Property(expression, property)` → "Static property requires null instance"。未改动的 PG 项目同样失败 ⇒ 既存问题。 + +**下一步**:MySQL/SqlServer 接入 → 6 处版本分支改读能力位 → `Resolve` 缓存键加 `Signature` → MariaDB/KES 厂商判别 → 显式覆盖 API(`IDbOption`)+ 旧枚举 `[Obsolete]` 映射。 + +## 重构:能力位下沉到 provider(用户指出核心不该知道方言词汇) +用户指出"主框架好像不需要关心这个"—— 判断正确。核对后核心的真实需求**只有一处**:表达式缓存是进程级静态的,需要一个"行为等价性"标识。除此之外核心不该解释任何能力含义。 +- 删除核心的 `DbFeatures`(`SqlServerStringAgg` / `MySqlGroupingSets` 这类名字出现在主框架里是反向依赖)。 +- **核心只留机制**:`Models/DbServerVersion.cs`(`CapabilitySource` + `DbServerVersion{Raw,Parsed,Source}`)、`Implements/DbVersionProbe.cs`(后台探测:单飞 / 限时 / 永不 fault / 后台自愈,**零方言词汇**)、`Interfaces/IDbCapabilitySource.cs`(只暴露一个签名成员)。 +- **provider 拥有方言知识**:`OracleCapabilities.cs` 定义 `public [Flags] enum OracleFeatures` + `MapFeatures(Version?, raw)` + `Override`,实现核心接口;`OracleProvider.Capabilities` 公开暴露。 +- 重构后复验 8 项全过:构造 212ms 无 IO;首读 249ms 得 `raw='21.3.0.0.0' parsed=21.3.0.0 [Probed] Features=IdentityColumn,JsonNativeType`;单飞生效;连不上等 2013ms(一次超时)后 Assumed;`ToSql` 可用;Override 生效;`None` 零 IO;签名能区分 11.2/None 与 21.3/Identity 且不跨方言撞(`MySql` 签名不同)。 + +## 【根因修正】缓存键的第一维度是"标识符引用身份",不是版本能力(用户指正) +我此前把 P0 定性为"版本维度缺失",**不准确**。实际: +- **标识符引用在解析期就写进了结果**:`ExpressionResolver` 358/425/430/474/565 行 `Sql.AppendEmphasis(col.ColumnName, Database)`;`AppendEmphasis`(`Extension/CustomDatabaseExtensions.cs:65`)读 `database.Emphasis` 与 `database.QuoteIdentifiers ?? database.UseIdentifierQuote`(关键词命中时强制加引用)。⇒ `ExpressionResolvedResult.SqlString` 自带 `[Col]` / `` `Col` `` / `"Col"`。 +- **参数前缀不在解析结果里**(用户指出,正确):解析期只用 `ResolveContext.ParameterPrefix`;`database.Prefix`(`@`/`?`/`:`)在下游 `SqlBuilder.HandleSqlParameters` 经 `database.AttachPrefix()` 补上(SqlBuilder.cs:82/90)⇒ 前缀不构成缓存维度。 +- **缓存无任何清理入口**:`expressionResolvedResultCache` 全仓库只有 `TryGetValue`/`TryAdd`,没有 `Clear`。 +- ⇒ **这是既存缺陷、与版本探测无关**:同进程两个方言(或同方言不同 `QuoteIdentifiers`)解析同一表达式,第二次会命中第一次的引用符号。 +- **正确的缓存键模型**:`(SqlAction, 标识符引用身份, Hash, Depth)`,其中"引用身份"至少含:`Emphasis` + 生效引用开关(`QuoteIdentifiers ?? UseIdentifierQuote`)+ 关键词集(命中即强制引用,故也算维度)+ provider 私有的版本身份(可选接口叠加,核心不解释)。 +- 注意 `QuoteIdentifiers` 是**每条语句**经 `ScopedDatabaseAdapter(database, quote)` 生效的,故该维度必须按"当次生效值"取,不能只看 adapter 实例。 + +## 【实测】方言隔离 A/B 跑通 + "只加 Emphasis 够不够"的反例(16:0x) + +### 先说一个此前踩的坑:多 provider A/B 的 harness 必须用不同 key +`ExpressionSqlOptions` 的 `databaseProviders` / `customDatabases` / `databaseHandlers` / `defaultDbKey` +**全是 static 全局**,而 `SetDatabase` 对同名 key 走 `TryAdd` → **先注册者胜、后来者被静默丢弃**。 +默认 key 是 `"MainDb"`(`ConstString.Main`),所以连续两次 `UseSqlServer(...)` / `UseMySql(...)` +(都走无 key 重载)时**只有第一个生效**,第二个 context 实际仍在用第一个方言的适配器 —— +我最初那次 A/B 里 MySql 输出了 `[PRODUCTS]` 就是这个原因,**不是缓存污染**。 + +正确做法:`UseSqlServer("SS", ...)` / `UseMySql("MY", ...)` 用**具名 key** 注册, +再用 `IExpressionContextSetup.SetDefault("SS"|"MY")` 切换(该方法也是全局的,但顺序调用即可)→ +同一进程、同一静态缓存里就能做真正的 A/B。 + +### DEMO 3:跨方言隔离(修复后的正确行为) +固定一条表达式,SS → MY → ORA 轮换解析,各自拿到正确的引用符号,且切回 SS 仍是 `[bracket]`: +``` +SS : SELECT a0.[PRODUCT_ID] ... FROM [PRODUCTS] a0 WHERE (a0.[PRODUCT_CODE] = 'xyz') +MY : SELECT a0.`PRODUCT_ID` ... FROM `PRODUCTS` a0 WHERE (a0.`PRODUCT_CODE` = 'xyz') +ORA: SELECT a0."PRODUCT_ID" ... FROM "PRODUCTS" a0 WHERE (a0."PRODUCT_CODE" = 'xyz') +``` +两方言各占一条缓存(`TryAdd` 先到先得,不覆盖),证明 `ResolveIdentity` 维度真的在起隔离作用。 + +### DEMO 1:**Emphasis 单独进键不够** —— 同 Emphasis、不同方言 +| 方言 | `Emphasis` | `UseIdentifierQuote` 默认 | 解析输出 | +|---|---|---|---| +| Oracle | `""` | `true` | `a0."PRODUCT_NAME" AS "ProductName"` / `FROM "PRODUCTS" a0` | +| PostgreSQL | `""` | **`false`** | `a0.PRODUCT_NAME AS ProductName` / `FROM PRODUCTS a0` | + +四个方言共用 `""`:Oracle / PostgreSQL / KingbaseES / Dameng +(`CustomOracleAdapter` / `CustomDamengAdapter.cs:15` / `CustomKingbaseESAdapter.cs:23`)。 +它们现在恰好因为引用开关默认值不同而分开,一旦用户给 PG 打开引用(`UseIdentifierQuote(true)`) +或给 Oracle 关掉,Embed 相同 ⇒ **只按 Emphasis 进键就会撞同一条缓存**。 + +### DEMO 2:同方言、同 Emphasis,逐语句翻转开关,结果就变 +`.QuoteIdentifiers()` / `.NoQuoteIdentifiers()` 经 `ScopedDatabaseAdapter` 覆盖当次生效值: +``` +SS 默认 : a0.[PRODUCT_NAME] / FROM [PRODUCTS] +SS NoQuoteIdentifiers: a0.PRODUCT_NAME / FROM PRODUCTS +SS 再默认 : a0.[PRODUCT_NAME] / FROM [PRODUCTS] +``` +⇒ 引用开关(`QuoteIdentifiers ?? UseIdentifierQuote`)是**独立于 Emphasis 的第二维度**,必须进键。 + +### 结论:Emphasis 是主维度但**不充分** +`Combine` 的三件套都是必要的: +1. `Emphasis` —— 引用符号字面量(`[]` / `` `` `` / `""`),覆盖大多数方言差异; +2. 生效引用开关 —— 同 Emphasis 的方言(PG vs Oracle)与同方言逐语句切换都靠它区分; +3. provider 私有 `IDbResolveIdentity` —— 版本/能力相关分支(`TRIM()`、`ROLLUP()`、自增列 DDL 等)的兜底。 + +**仍未覆盖(诚实边界)**:`keyWorks` 关键词集。`CustomDatabaseAdapter.IsKeyWord` 读的是 +**per-adapter 可变的** `HashSet`(`AddKeyWord` 可追加),引用关闭时命中关键词仍强制加引号。 +默认关键词集未变时无影响;需要时由 provider 在自己的 `IDbResolveIdentity` 里并入 —— 这正是留的口子。 +`Prefix` 确认**不是**维度(`AppendEmphasis` 完全不读它,前缀在 `SqlBuilder.HandleSqlParameters` 由 `AttachPrefix` 补)。 + +## 【追问】"身份 == Emphasis 就够了吗" —— 单方言隔离矩阵实测(16:3x) + +用户追问:**Emphasis 相同 ⇒ 解析结果可复用?"实际上有没有用到 Emphasis"有关系吗?** +结论:**不成立,而且与"有没有用到 Emphasis"无关** —— 解析期从 adapter 读的东西不止引用符号。 + +### 关键:单方言独立进程取真值(多方言同进程会被污染,不可信) +探针 `%TEMP%\dbver-probe`,每次进程只注册**一个**方言(`dotnet run -- `): + +| 运行时 key | Emphasis | 引用开关 | bool 字面量 | 标识符 | +|---|---|---|---|---| +| Oracle | `""` | true | **`1`** | `"ACCOUNTS"` / `"NICKNAME"` | +| Oracle-quote | `""` | true | `1` | 同上 | +| **PostgreSQL-quote** | **`""`** | **true** | **`TRUE`** | `"ACCOUNTS"` / `"NICKNAME"` | +| PostgreSQL | `""` | false | `TRUE` | 裸 | +| SqlServer V1 / Over2017 | `[]` | true | `1` | `[ACCOUNTS]` | + +⇒ **Oracle 与 PG(引用显式打开):Emphasis 相同(`""`)、引用开关相同(true),bool 字面量一个是 `1` 一个是 `TRUE`。** +差异来自 `FormatBooleanValue`(PG/KES 覆写返回 `TRUE`/`FALSE`,其余基类 `1`/`0`), +由 `ExpressionResolver:670/675 → Database.HandleBooleanValue` **在解析期写进 `SqlString`**。 +⇒ 只按 Emphasis 建键,这两条会复用 → PG 拿到 `1`(而 PG 正确值是 `TRUE`)。 + +### 解析期读 adapter 的**全部**位置(`ExpressionResolver.cs`) +| 行 | 读取 | 方言相关 | 引用开关能影响吗 | +|---|---|---|---| +| 358 / 432 / 476 | `AppendEmphasis`(列名 / 别名) | 是 | **能**(开关 false 且非关键词 → 裸) | +| 129 | `Context.Database.MethodResolver` | 是(且 **SqlServer 按版本**注入) | 否 | +| 548 | `HandleJsonColumn` | 是(每方言一套函数族) | 否 | +| 670 / 675 | `HandleBooleanValue → FormatBooleanValue` | 是(PG/KES = TRUE/FALSE) | 否 | +| 680 | `HandleDateValue`(**基类 abstract,6 个方言各自覆写**) | 是(Oracle `TO_DATE` / PG `TO_TIMESTAMP` / MySql `STR_TO_DATE` / SQLite 裸串) | 否 | + +⇒ **"有没有用到 Emphasis"不是判据;判据是"解析结果是不是 Emphasis 的函数"——它不是。** +只要 adapter 的任一解析期行为不同,结果就不同,而身份里只放 Emphasis 覆盖不到。 + +### 顺带确认的两点 +- **关键词兜底确实存在**(引用关也有 Emphasis):单方言实测 `NoQuoteIdentifiers()` + 列名 `USER` + → SS `a0.[USER]`、MY `` a0.`USER` ``、ORA `a0."USER"`、PG `a0."USER"`(`USER` 在默认 `keyWorks` 里)。 + 非关键词列则一律裸名 → 这部分确实与方言无关。 +- **SqlServer V1 vs Over2017 的 `Trim` 分支是冗余的**:`SqlServerMethodResolver.Trim` 的 else 走 + `BaseSqlMethodResolver.Trim`(`BaseSqlMethodResolver.cs:445`),输出同样是 `TRIM(...)` ⇒ 两档输出**逐字节相同**。 + (不是缓存问题,是这条版本分支没有实际差异。) + +### ⚠️ 未解释的异常(待查,可能是真缺陷) +多方言同进程(ab8 的 P1)里:先 Oracle 后 PG,PG 的 bool 输出是 `1`(Oracle 的值)而不是 `TRUE`, +且连同 `"ID" AS "Id"` 一起是 Oracle 的整段输出 ⇒ 说明**投影段/该表达式的缓存身份没起作用**。 +但同一表达式在单方言进程里两者各自正确 ⇒ 是**跨方言复用**,不是解析错误。 +按 `Combine` 的公式 Oracle(有 `IDbResolveIdentity`)与 PG(无 → None=0)本应不同键,故怀疑: +① `IDbResolveIdentity` 在投影段没被探到;② 投影段走的 `ResolveContext.Database` 不是当次 adapter。 +—— 这条要单独定位,是"身份是否真的生效"的核心疑点。 + +### 结论(设计取向) +不要继续枚举属性(已经出现 4 个:Emphasis、引用开关、`keyWorks`、`FormatBooleanValue`/`HandleDateValue`)。 +**身份应当默认取"adapter 行为身份"**:穿透 `ScopedDatabaseAdapter` 取 inner 实例身份 + 当次引用开关; +provider 再用 `IDbResolveIdentity` 声明可共享的行为签名(方言+能力位+版本)以恢复跨实例复用。 +这样"漏掉某个属性"在结构上不可能发生,而不是靠人肉维护清单。 + +## 缓存键改动的 SQLite 全量回归 + 基线交叉验证(16:40) + +**现象**:`LightORMTest.Sqlite` 全量 167 用例 / 150 通过 / **17 失败**(34m51s),初看像回归。 + +**基线交叉验证(关键动作)**:把 `src/LightORM/Utils/ExpressionResolver.cs` 临时还原成 `HEAD` 版本 +(其余未提交文件不动),重编译后按失败项分组跑同样用例: + +| 组 | 用例 | 基线结果 | +|---|---|---| +| 6 个秒级失败 | `SelectWithAttr` / `InsertRange` / `TestSelectOneTable` / `Select_Navigate_Where_Single` / `TestArrayAccess_List` / `TestRowNumberWindowFunc` | **6/6 同样失败** | +| 3 个 Group | `Group_Rollup_Coalesce_Test` / `Group_Rollup_NullThen_Test` / `Group_Cube_Test` | **3/3 同样失败**(`no such function: ROLLUP` / `CUBE`) | +| 慢用例组 8 个 | `Repository_Methods_Test` / `Repository_Async_Operations_Test` / `Delete_FullDelete_Test` / `Group_Rollup_Test` / `Transaction_Atomicity_Test` / `Transaction_Concurrency_Test` / `Select_WithTempQuery_Two_Test` / `Select_AsTemp_WithTempQuery_Test` | **5 失败(同错)/ 3 通过** | + +⇒ **17 项里 14 项在基线上逐字复现;剩下 3 项(`Repository_Methods_Test`、`Select_WithTempQuery_*`) +在基线隔离跑是通过的,只在全量套件里失败 ⇒ 是**顺序/级联**问题**(`Transaction_Atomicity_Test` 回滚未发生 → +事务未关残留锁 + 早前失败用例污染静态全局 `defaultDbKey`),同样与缓存键无关。 +**结论:17 项全部是既有失败,本次改动零回归。** 逻辑上也自洽:加维度让键**更细**,只可能增加 miss、不可能造成错误复用。 + +基线验证手法:`cp` 备份工作区文件 → `git show HEAD: > ` 还原单个文件(**不动其他未提交改动**, +也不用 `git stash`)→ 重编译 → 跑同批过滤用例 → `cp` 还原。比全量对比省 30 分钟。 + +## 【决策】缓存键(解析身份)改动整体回滚,只保留版本探测线(16:55) + +用户决定:**先不处理缓存键的问题,回滚相关代码。** + +### 已回滚 / 删除 +| 项 | 处置 | +|---|---| +| `src/LightORM/Utils/ExpressionResolver.cs` | `git show HEAD:` 还原,`CacheKey` 回到 `(SqlAction, Hash, NestedLevel)`,与 HEAD **零差异** | +| `src/LightORM/Models/DbResolveIdentity.cs` | 删除(`Combine` / `ForProvider` / `None`) | +| `src/LightORM/Interfaces/IDbResolveIdentity.cs` | 删除 | +| `OracleCapabilities` | 去掉 `: IDbResolveIdentity` 与 `ResolveIdentity` 属性,去掉多余 `using LightORM.Interfaces` | +| `CustomOracleAdapter` | 去掉 `, IDbResolveIdentity` 与 `ResolveIdentity` 成员(`Capabilities` 属性保留) | + +### 保留(版本探测线,用户此前明确要做) +`src/LightORM/Models/DbServerVersion.cs`、`src/LightORM/Implements/DbVersionProbe.cs`、 +`src/Providers/LightORM.Providers.Oracle/OracleCapabilities.cs`(含 `OracleFeatures` / `MapFeatures` / +`Start` / `Baseline` / `Override` / `ServerVersion` / `Features`)、`OracleProvider.Capabilities` 注入、 +`CustomOracleAdapter(…, OracleCapabilities capabilities)` 参数与 `Capabilities` 属性。 + +- 验证:`grep -rn "ResolveIdentity\|DbResolveIdentity" --include=*.cs src/ test/` **零命中**; + `dotnet build src/Providers/LightORM.Providers.Oracle` 多目标框架 **0 错误**。 + +### 留档:这条线的结论别重推(证据都在上面几节) +- 缺陷是**既存的**,与版本探测无关;正确键模型 = `(SqlAction, 标识符引用身份, Hash, Depth)`, + 单放 `Emphasis` 不充分(反例见 DEMO 1/2 与单方言矩阵)。 +- **待办(重新捡起时先做)**:定位 ab8 那条"PG 输出整段是 Oracle 的"异常 + —— 怀疑投影段的 `ResolveContext.Database` 不是当次 adapter,或 `TryGet` 探不到。 + +## 显式指定版本时跳过后台探测(17:15) + +需求:`TableOptions` 上若已指定版本,创建 `OracleCapabilities` 时**不开启后台 Task**。 + +**先说事实**:`public Version? SpecificVersion { get; set; }` **已经在基类** +`src/LightORM/DbStruct/TableGenerateOption.cs:9`(`TableOptions`)里了,无需新增。 + +### 改动 +1. `OracleCapabilities` 新增: + ```csharp + public static OracleCapabilities ForVersion(Version version) + { + var capabilities = new OracleCapabilities(DbVersionProbe.None); + capabilities.Override(version); + return capabilities; + } + public static OracleCapabilities Start(DbProviderFactory factory, string connectionString, Version? specificVersion = null) + => specificVersion is null + ? new(DbVersionProbe.Start(DbBaseType.Oracle.Name, factory, connectionString)) + : ForVersion(specificVersion); + ``` +2. `OracleProvider` 构造期把 `option.GenerateOption.SpecificVersion` 传进去。 +3. **顺带修掉一个共享单例陷阱**:`DbVersionProbe.None` 原本是 `{ get; } = new(null)` 的**共享实例**, + 而 `Override` 改的是**实例字段** → `ForVersion` 里的 `Override` 会污染 + `OracleCapabilities.Baseline`(它也包着同一个 `None`)。改成 + `public static DbVersionProbe None => new(null);`(每次新实例)。 + +### 验证(探针 `%TEMP%\dbver-probe`,5 项全过;用黑洞地址 `10.255.255.1:1521` 区分"探测了/没探测") +| # | 场景 | 结果 | +|---|---|---| +| 1 | 未指定版本 + 黑洞串 | 构造后 `IsResolved=False`;读 `Version` 等 **2040ms**(一次建连)→ `Assumed` ✅ | +| 2 | `SpecificVersion=21.3.0.0` + 黑洞串 | 构造后 `IsResolved=True`;读 `Version` **0ms**、`Source=Explicit`、`Features=IdentityColumn,JsonNativeType` ✅ | +| 3 | `SpecificVersion=11.2` | `Features=None`、`Source=Explicit` ✅ | +| 4 | 污染检查 | `Baseline` 仍是 `null/Assumed/None`;两个 `None` 非同一实例 ✅ | +| 5 | 正常探测路径 | 171ms、`Raw='21.3.0.0.0'`、`Source=Probed`、`Features=IdentityColumn,JsonNativeType` ✅ | + +`dotnet build test/LightORMTest.Oracle`(net10.0)**0 错误**。 + +### 遗留不一致(未改) +`Features` 目前**还没接到任何 SQL 分支**,而 Oracle DDL 仍读 `OracleTableOptions.OverVersion`。 +所以 `SpecificVersion=21.3` 会让 `Features` 报 `IdentityColumn`,但建表仍走序列+触发器。 +把 6 处版本分支改读能力位(或让 `OverVersion` 从版本推导)时应一并处理。 + +## 删除 OracleTableOptions.OverVersion,DDL 分支改读能力位(17:25) + +### 改动 +| 文件 | 变化 | +|---|---| +| `OracleTableOptions.cs` | **删除 `OverVersion`** | +| `OracleTableHandler` | 主构造新增 `OracleCapabilities capabilities`;新增 `private bool UseIdentityColumn => capabilities.Features.HasFlag(OracleFeatures.IdentityColumn)`;`GetDropTableSql` 的 `!tableOptions.OverVersion` → `!UseIdentityColumn` | +| `OracleTableHandler.Writer.cs` | `!option.OverVersion` → `!UseIdentityColumn`;`BuildColumn` 的 identity 判断同上 | +| `OracleProvider` | **调整构造顺序**:先 `Capabilities` 再 `DbHandler`(handler 依赖能力档案) | +| `test/LightORMTest.Oracle/SqlGenerate/InsertOrUpdateTest.cs` | `t.OverVersion = true` → `t.SpecificVersion = new Version(21, 3, 0, 0)` | + +### ⚠️ 顺带修掉一个既有的隐藏 bug(被我这次改动暴露) +`BuildColumn` 原来的拼接顺序是 `{type} {default} {notNull} {identity}`,即 +`"ID" NUMBER(10) NOT NULL GENERATED ALWAYS AS IDENTITY`。**这在 Oracle 上非法**, +实测 21c: + +| DDL | 结果 | +|---|---| +| `NUMBER(10) NOT NULL GENERATED ALWAYS AS IDENTITY` | **ORA-00907 缺失右括号** | +| `NUMBER(10) GENERATED ALWAYS AS IDENTITY NOT NULL` | OK(自增实测 ID=1) | +| `NUMBER(10) GENERATED ALWAYS AS IDENTITY NULL` | **ORA-30670 身份列上指定的 NOT NULL 约束条件无效** | + +⇒ 身份列必须:**`GENERATED ... AS IDENTITY` 紧跟数据类型**,且 **不能显式写 `NULL`**。 +所以改成 `{name} {type}{identity} {default} {notNull}`,且 `useIdentity` 时 `notNull` 强制 `NOT NULL` +(非身份列的输出与原来逐字相同,不动其他方言/其他分支)。 + +**为什么之前没暴露**:`ResultTest.ExecutionTest`(唯一真正建表的套件)用的是 `OverVersion` 默认 false +→ 走序列+触发器;带 `OverVersion = true` 的 `SqlGenerate/InsertOrUpdateTest` **只生成 SQL 不连库**。 +现在版本探测让 21c 默认启用 IDENTITY,就正好踩中。 + +**排查要点**:`InternalCreateTableAsync` **catch 掉所有异常并 return false** —— DDL 失败不会抛, +只在后续 `FullDelete` 时以 `ORA-00942 表或视图不存在` 冒出来。以后遇到 ORA-00942 先怀疑建表静默失败。 + +### 回归(Oracle 全量 194 用例,基线对照法) +| | 失败 | 通过 | +|---|---|---| +| 基线(6 个文件还原 HEAD) | **18** | 176 | +| 本次改动 | **17** | 177 | + +失败集合差集:`仅在基线失败 = {Select_Result_Test}`(flaky,我这边通过); +`仅在我这边失败 = ∅` ⇒ **零新增回归**。构建 0 错误。 + +### 其他实测确认 +- 序列回退路径的 `INCREMENT BY 1MINVALUE 1` 连写 **Oracle 能接受**(词法上分开解析),不是 bug,未改。 +- 探测路径 `OracleCapabilities.Version=21.3.0.0 / Source=Probed`;显式路径 0ms / `Explicit`; + 建表 DDL 三者实测:`SpecificVersion=21.3`→IDENTITY、无法探测→序列+触发器、真实库探测→IDENTITY。 + +**17 项的成因分类**(错误签名,与缓存无关): +- `实体上没有设置DatabaseKey` / `无法确定默认数据库`(测试工程多库注册缺失)→ `SelectWithAttr`、`Repository_Methods_Test`、`Repository_Async_Operations_Test`、`Delete_FullDelete_Test` +- `ResolveHelper.CreateGetter` 的 `Expression.Property` 静态属性 / `Expression.Equal` 类型不匹配 / 越界 → `TestSelectOneTable`、`Select_Navigate_Where_Single`、`TestArrayAccess_List`、`TestRowNumberWindowFunc`(**与 Oracle/PG 项目同一批既存失败**) +- SQLite 无 `ROLLUP`/`CUBE`/`TRUNCATE` → `Group_Rollup*`、`Group_Cube_Test`、`InsertRange`、`Select_*TempQuery*` +- `Transaction_Atomicity_Test` 回滚未发生 → 后续用例锁级联 `database is locked`(`Transaction_Concurrency_Test` 及若干 ~20s 项) + +**注意**:`test.db` 是被跟踪文件且被改动,跑完测试会脏;不要用 `git stash`(见 MEMORY.md)。 + +## 连接超时键名下沉到方言(17:35) + +用户指出:`DbVersionProbe.ApplyConnectTimeout` 里那个候选键数组是**方言词汇写在核心** —— +和之前 `DbFeatures` 同一个问题,键名该由方言给。 + +### 先实测:单键方案够不够(探针,7 个驱动的 `CreateConnectionStringBuilder`) + +判定标准三条:赋值不抛异常 / **读回值 == 写入值**(防"静默忽略未知键"的驱动)/ 连接串确实变了。 + +| 方言 | `Connection Timeout` | `Connect Timeout` | `Timeout` | `ConnectionTimeout` | +|---|---|---|---|---| +| SqlServer | ✅ | ✅(别名) | ✅(别名) | ❌ 不支持的关键字 | +| MySql | ✅ | ✅ | ❌ Option 'Timeout' not supported | ✅ | +| PostgreSQL | ❌ | ❌ | ✅ | ❌ | +| KingbaseES | ❌ | ❌ | ✅ | ❌ | +| Oracle | ✅ | ❌ ORA-50008 | ❌ ORA-50008 | ❌ ORA-50008 | +| Dameng | ❌ does not exist | ✅ | ✅ | ✅ | +| Sqlite | ✅ | ✅ | ✅ | ✅ | + +⇒ **每个方言一个规范键即可**:SqlServer/MySql/Oracle/Sqlite = `Connection Timeout`、 +Npgsql/Kdbndp = `Timeout`、Dameng = `Connect Timeout`。 + +⚠️ 注意 `Command Timeout` 在 SqlServer/MySql/PG/KES **四个驱动里都被接受且读回相等** —— +它映射的是**另一个属性**(命令超时),所以"读回校验"并不能区分这两个键。 +⇒ 这也是必须让**方言给键**、而不是核心枚举候选的另一个理由:候选法可能挑中语义不同的键。 + +### 改动 + +- `DbVersionProbe.Start(...)` 新增必填参数 `string? connectTimeoutKey`,删掉静态 `timeoutKeys` 数组; + `ApplyConnectTimeout` 改为单键 + **写入后读回校验**(不一致 / 驱动不认这个键 → 放弃改写、沿用原串)。 + 核心现在零方言词汇。 +- `OracleCapabilities.ConnectTimeoutKey = "Connection Timeout"`(`internal const`,含"不能写成 + `Connect Timeout`/`Timeout`"的注释);`OracleCapabilities.Start` 传给探测。 + +其余 6 个 provider 尚未接探测,键名已记在上表,接的时候各自传自己的。 + +## Oracle JSON 能力位接上(17:45) + +### 实测定界(Oracle 21c XE 探针) + +| 构造 | 12.1 | 19c | 21c | +|---|---|---|---| +| `JSON` 列类型 / `JSON('...')` 构造器 | ❌ | ❌ **ORA-00902** | ✅ | +| `JSON_TRANSFORM(... SET ...)` 路径更新 | ❌ | ❌(**19.11+ 部分 RU 回移**) | ✅ | +| `JSON_MERGEPATCH` | ❌(`JSON_MERGE_PATCH` 旧名在 21.3 上是 ORA-00904) | ✅ | ✅ | +| `JSON_VALUE` / `JSON_QUERY` / `FORMAT JSON` | ✅ | ✅ | ✅ | + +21c 实测细节:`JSON('{"a":1}')` ✅;`CAST('...' AS JSON)` → **ORA-00600 内部错误**(21.3 XE 的坑); +`CLOB` 列上 `JSON_VALUE` / `JSON_TRANSFORM` / `JSON_MERGEPATCH` 全部可用(无需 `IS JSON` 约束); +`JSON_TRANSFORM` 首参为 NULL → 返回 NULL(既有注释成立)。 + +### 分支设计(`JsonNativeType` = 原生 JSON 能力,21c+) + +| 位置 | 21c+(`JsonNativeType` on) | ≤19c(off) | +|---|---|---| +| `OracleTableHandler.Writer.ConvertToDbType` | 列类型 `JSON` | 列类型 **`CLOB`** | +| `CustomOracleAdapter.HandleJsonColumn` 路径更新值 | `SET '$.p' = JSON(:p)` | `SET '$.p' = :p FORMAT JSON` | + +- 关键取舍:非原生分支用 **`FORMAT JSON` 子句**替代 `JSON()` 构造器,**不用 `JSON_MERGEPATCH`**。 + 理由:① `FORMAT JSON` 不依赖 JSON 类型,语义与构造器逐字节一致(实测数值/字符串/对象/null 四种); + ② `JSON_MERGEPATCH` 是**整文档合并**语义,与"设置某个路径"不等价(对象会合并、数组下标无法设置), + 用它会在 ≤19c 上静默产生错误数据;③ 用 `FORMAT JSON` 还能顺带吃到 19.11+ 的回移版 + (那版有 JSON_TRANSFORM 但**没有** `JSON()` 构造器)。 +- **未动** `OracleMethodResolver.JsonSet`(`SqlFn.JsonSet` 的口子):它的值是**用户自己写的 SQL 表达式** + (如 PostgreSQL 那种要写 `'"NewName"'`),改成 `FORMAT JSON` 会把 `'test'` 变成非法 JSON 文本 ⇒ 回归。 + 框架生成的路径更新不一样 —— 那里的值一定是 `JsonParameterHelper.Serialize` 出来的合法 JSON 文档。 +- `MapFeatures(null)` 仍返回 `None` ⇒ 版本未知时退化到**全版本可用**的写法(CLOB + FORMAT JSON)。 + 与 `IdentityColumn` 的"未知就退序列+触发器"同一取向。后台重试自愈后 `Features` 会跟着变(`Value` 读 `Healed`)。 + +### 验证 + +- 探针(21c 实库)`FORMAT JSON` vs `JSON(:p)` 在原生列上**输出逐字节相同**; + CLOB 列上 `FORMAT JSON` 的值/下标路径更新、`JSON_VALUE`/`JSON_QUERY` 读取、整列 `d = :p` 赋值全通过。 +- **端到端**:临时在 Oracle `ResultTest/ExecutionTest.cs` 的 `ConfigureOracle` 里塞 + `o.SpecificVersion = new Version(11, 2)` 强行走非原生分支: + - `--filter FullyQualifiedName~JsonColumn` → **18/18 通过**; + - 直接查 `user_tab_columns`:`JSON_EXEC_TEST.DATA/ARR/LST/OBJ` 从 `JSON` 变成 **`CLOB`**(分支真的生效,不是"反正 21c 都接受")。还原后再查回到 `JSON`。 +- 全量回归(native):Oracle **194 用例 / 177 通过 / 17 失败**,与改动前完全一致(17 项全部既有失败,无一条 json 用例)。 +- 临时改动已还原(`grep -c SpecificVersion` = 0)。 + +### ⚠️ 未解决:解析期版本分支与静态缓存键的冲突(用户已决定暂不处理) + +`HandleJsonColumn` 在**表达式解析期**执行,而 `expressionResolvedResultCache` 的键是 +`(SqlAction, Hash, NestedLevel)`,**没有版本/能力维度**。所以同进程里两个不同版本的 Oracle provider +(如 19c + 21c)会共用同一条 JSON 路径更新缓存 ⇒ 串味。 +⇒ 本次新增的 JSON 分支**扩大了**这个既存缺陷的暴露面(原来只有 `MethodResolver` 一处版本相关)。 +缓存键那条线已按用户要求整体回滚,这里只做记录。 + +### 放弃项:HandleJsonColumn 三段能力门(用户决定不做) + +原计划在 `CustomOracleAdapter.HandleJsonColumn` 里加三道判断(是否支持 JSON 操作 / `JSON_TRANSFORM` / `FORMAT JSON`)。 +**用户结论:不做** —— "反正不支持的时候 sql 本身会报错"。不再加探测 SQL、不再加能力位。 +若将来要做,下面是这次调研查到的**版本边界事实**(本地只有 21c,无法实测 ≤19c,故来自 Oracle 官方文档/论坛): + +| 能力 | 引入版本 | 关键细节 | +|---|---|---| +| `JSON_VALUE` / `JSON_QUERY`(SQL/JSON 查询) | **12.1.0.2** | 11g 完全没有;12.2 起被改写成 `JSON_TABLE`(行为差异) | +| `FORMAT JSON` 子句 | 12.1 语法接受,**18c 才真正生效** | 12c 文档原文"optional and provided for semantic clarity",且实测有 bug(含不含该子句会影响输出但不稳定,seanstuber 2019 有专文);18c/19c 文档改为"指示输入是 JSON,因此输出不加引号" | +| `JSON_TRANSFORM` | **21c**,回移 **19c 仅"较新子版本"** | 19.3 无、19.17 有(Oracle 论坛 mathguy 实证);⇒ 版本号**不可靠**,要精确只能实测 `SELECT JSON_TRANSFORM(...)` | +| 原生 `JSON` 类型 + `JSON()` 构造器 | **21c** | 19c 建表报 ORA-00902(本次已由 `OracleFeatures.JsonNativeType` 覆盖) | + +⇒ 若重启该项,`JSON_TRANSFORM` 那一档必须用**实测探测**而非版本映射(19c 回移点不可知)。 +可复用的探测形态(一条标量查询,支持返回 1、不支持靠异常返回 0): +`SELECT CASE WHEN JSON_TRANSFORM('{"a":1}', SET '$.b' = 2) IS NOT NULL THEN 1 ELSE 0 END FROM dual`。 + + +## 连接超时改写下沉到方言(用户提议,已落地) + +用户问:`ApplyConnectTimeout` 为什么不直接由方言传入,比如 Oracle 直接用 `OracleConnectionStringBuilder`。 + +**同意,改掉。** 键名方案两个洞:① 魔法字符串 + 运行期才知道对错,故要"写回读校验"兜底,而**校验区分不了语义不同的键**(实测 `Command Timeout` 在 SqlServer/MySql/PG/KES 都接受且读回相等);② 核心被迫持有方言词汇(以 `connectTimeoutKey` 参数形式)。 + +**新形态**(核心只给策略,表达方式归方言): + +```csharp +// 核心 +public static DbVersionProbe Start(string target, DbProviderFactory factory, string connectionString, + Func? prepareConnectString, int timeoutSeconds = 2, ...) +// 内部 PrepareConnectString(cs, prepare, seconds):prepare 为 null / 返回 null / 抛异常 → 一律沿用原串 +``` + +```csharp +// Oracle(OracleCapabilities.PrepareProbeConnectString,internal static) +var builder = new OracleConnectionStringBuilder(connectionString) { ConnectionTimeout = timeoutSeconds }; +return builder.ConnectionString; // 失败 → null +``` + +`ApplyConnectTimeout`(含 `factory.CreateConnectionStringBuilder()` + 读回校验)与 `ConnectTimeoutKey` 常量**整块删除**,`grep` 零残留。 + +### 验证(探针项目,反射调 internal 方法 + 真实驱动) + +| # | 项 | 结果 | +|---|---|---| +| 1 | 改写结果 | `USER ID=…;DATA SOURCE=localhost:1521/XE;CONNECTION TIMEOUT=2`(业务键保留) | +| 1b | 非法连接串 | 返回 null(核心沿用原串)✅ | +| 2a | 黑洞地址+原串 5s | **5090 ms** | +| 2b | 同一串改写为 2s | **2001 ms** ⇒ 改写真生效 | +| 3 | 真实库探测 | `21.3.0.0.0 [Probed]`、`Features=IdentityColumn,JsonNativeType` ✅ | +| 4 | 构造不阻塞(黑洞) | 构造 **1 ms**、`IsResolved=False`、读 Version **2014 ms → Assumed**(恰好一次超时,非 3 次累加)✅ | + +⚠️ 踩到的新事实:**ODP.NET 的 `OracleConnectionStringBuilder` 输出会把键名大写归一化**(`CONNECTION TIMEOUT=2`),键名大小写不敏感;用原文 `Contains` 断言会假失败(我第一次就踩了)。 +另:探针里 `IsResolved` 在 localhost 上常打印 `True` —— 建连几毫秒就完成,是时间相关而非构造阻塞(构造阻塞要用黑洞地址测)。 + +回归:Oracle 全量 **18 失败 / 176 通过**,与基线一致;`Select_Result_Test` 单独跑通过(已知 flaky),其余 17 项既有失败 ⇒ **零回归**。核心与 Oracle provider 编译 0 错误。 + +--- + +## MySQL / SqlServer 版本能力梳理(调研,未改代码) + +### MySQL(改动面极小) +- 版本只影响 **1 处**:`CustomMySqlAdapter.HandleSelectGroupBySegment:23` 的 `tableOptions.Version > new Version(8,0)`(8.0+ 用 `ROLLUP()/CUBE/GROUPING SETS`,否则 `WITH ROLLUP` 或抛 NotSupported)。 +- 缺陷 ①:`MySqlTableOptions.Version` 与基类 `TableOptions.SpecificVersion`(TableGenerateOption.cs:9)语义重复 → 应删 `Version`。 +- 缺陷 ②:`>` 严格大于导致 `new Version(8,0)` 与 `new Version(8,0,0)` 都判 false(Build=0 相等)→ 退化成 `WITH ROLLUP`。应 `>= 8.0`。 +- 能力位只需 `GroupByRollup`(8.0.0+)。JSON 相关(`JSON` 列类型 5.7.8+、`->>`、`CAST(? AS JSON)`)5.7/8.0 都可用 → **不值得加能力位**(除要支持 5.6)。 +- 探测:`DbBaseType.MySql.Name`;`MySqlProvider` 第 40 行才赋值 `DbProviderFactory`,而 handler/adapter 在 34~37 行创建 → 接入须先取 factory(同 Oracle)。 + +### SqlServer(公开 API 破坏面大) +- 三档枚举 `SqlServerVersion{V1,Over2012,Over2017}` 扩散:`CustomSqlServerAdapter.Paging`(`== Over2012`)、`SqlServerMethodResolver.Trim`(`== Over2017`)、`.Value`(`< Over2017` 抛 STRING_AGG 不支持);另 IoCExtension 3 重载 + `DatabaseUtils.Avalonia/MainViewModel.cs:36` + **12 个测试文件** + `doc/项目大纲.md:547,550`。 +- 缺陷 ①:`Paging` 只判 `== Over2012` → **Over2017 跌回老式 ROW_NUMBER 分页**(`test/LightORMTest.SqlServer/ResultTest/ExecutionTest.cs:10` 正是 Over2017)。能力位化后 Over2017 改走 OFFSET/FETCH → **已生成 SQL 变化,断言分页文本的测试需同步**。 +- 缺陷 ②:JSON 完全无版本门控,但 `JSON_VALUE/JSON_QUERY/JSON_MODIFY` 需 **2016(13.0)+** → V1/Over2012 跑 JSON 用例运行期报错。应加 `JsonFunction` 位。 +- 能力位:`OffsetFetch`=11.0+、`JsonFunction`=13.0+、`TrimFunction`=14.0+、`StringAgg`=14.0+(**已查证:`WITHIN GROUP` 自 2017 起支持,不是 2022**,现有代码无缺陷)。 +- 兼容:`SqlServerVersion` 与 `Create(version,…)` 标 `[Obsolete]` 映射为 `ForVersion`(V1→null 基线 / Over2012→11.0 / Over2017→14.0),主推 `SpecificVersion` + 无版本参新重载。 +- 探测:`Microsoft.Data.SqlClient.SqlConnectionStringBuilder.ConnectTimeout`(int);net462 走 `System.Data.SqlClient`(provider 已有 `#if NET462_OR_GREATER` 模式)。ServerVersion "16.00.1000" → 三段可解析。 +- ⚠️ 同进程风险:`LightORMTest.SqlServer` 各测试类共用同一进程且 V1/Over2017 并存,而 `ExpressionResolver` 静态缓存 key 无版本维度 → 同一表达式(如 `Trim`)可能串味命中。该线已按用户要求回滚,**SQL Server 是唯一会真踩的方言**,待重提。 + +### 连接串超时属性(已核对包内 XML 文档) +- `MySqlConnector.MySqlConnectionStringBuilder.ConnectionTimeout`(**uint**,赋 int 要 cast;同类型还有 `DefaultCommandTimeout`,印证"Command Timeout 也被接受"的坑) +- `Microsoft.Data.SqlClient.SqlConnectionStringBuilder.ConnectTimeout`(int) +- NuGet 全局包目录是 **`F:\nuget\packages`**(不是 E 盘)。 + +--- + +## 落地:SQL Server + MySQL + Oracle 的版本能力重构 + +### 用户定的口径(重要,后续方言照此办理) +1. **只在"同一功能有多套实现"处才按版本判断**;只有一种实现的**不判版本**,交给数据库报错("自己抛 NotSupported 和数据库报错差别不大")。 +2. 版本判断**直接比版本分量**(`Major`/`Minor`),不构造 `new Version(...)` 实例比较。 +3. 版本探测是**可选功能**:`SpecificVersion` 已指定 / `DetectVersion = false` / 连接串为空 → 都不探测。探测失败与这些出口同结果。 +4. 唯一索引/约束等 DDL 能力若存在版本差异(如 MySQL 函数索引仅 8.0.13+)也要按此口径考虑。 + +### 基类 +`TableOptions` 新增 `bool DetectVersion { get; set; } = true`(`DbStruct/TableGenerateOption.cs`),与 `SpecificVersion` 并列。 + +### SQL Server +- **删除 `SqlServerVersion` 枚举**(V1/Over2012/Over2017),`SqlServerProvider.Create` 不再收版本;`IoCExtension` 的 3 个 `UseSqlServer` 重载简化成 2 个(去掉带 `key` 的那个——它会与 `(string master, params string[])` 产生重载歧义),连带改 `DatabaseUtils/WpfApp.razor.cs`、`DatabaseUtils.Avalonia/MainViewModel.cs` 与 11 个测试文件。 +- 新增 `SqlServerCapabilities`(`SqlServerFeatures`):**只保留 2 个位**——`OffsetFetch`(2012+,`OFFSET/FETCH` vs `ROW_NUMBER` 包裹)、`TrimFunction`(2017+,`TRIM()` vs `LTRIM(RTRIM())`)。原 `JsonFunction`/`StringAgg` 按口径删除(JSON 函数仅 2016+、`STRING_AGG` 仅 2017+,都只有一种写法)。 +- 基线:**乐观(未知 → Full)**。理由:这两个位都是"新写法在旧库报错、旧写法在新库仍可跑"。 +- `SqlServerMethodResolver` 构造改收 capabilities(另留无参构造 = Baseline);`CustomSqlServerAdapter` 同。 +- **修了一个被新代码暴露的既有缺陷**:`OFFSET/FETCH` 要求前面必须有 `ORDER BY`,否则 `Incorrect syntax near 'OFFSET'` / `Invalid usage of the option NEXT`。老代码 `Paging` 只判 `== Over2012`,而测试用的是 `V1`/`Over2017` → 全走 ROW_NUMBER 分支,**新式分页从未被执行过**;接上探测后(探测到 16.0)才第一次真正生成。修法:`builder.OrderBy.Count == 0` 时按主键补 `ORDER BY`(`SelectBuilder` 正是 `OrderBy.Count > 0` 才写 ORDER BY,信号精确)。 +- 测试(262 用例):改动后全量 18 失败 → 修分页后 `Select_Paging_Test` 两个副本**单独跑均通过**(640ms/627ms)。剩余失败原因分类:10 个是 `InitDatas` 里 `DROP TABLE` 锁超时(级联/环境)、其余是既有表达式 bug(`The binary operator Equal is not defined for types 'String' and 'Nullable[DateTime]'`、`IndexOutOfRangeException`、`Static property requires null instance`)。**没有任何一个错误是 SQL 语法/函数不支持**。 + - 判既有失败的好证据:`TestRowNumberWindowFunc` / `TestSelectOneTable` / `TestArrayAccess_List` / `Select_Navigate_Where_Single` 在 **SqlServer、Oracle、MySQL 三个方言同时失败**,错误一致,且都与版本能力位无关。 + +### MySQL +- **删除 `MySqlTableOptions.Version`**(与基类 `SpecificVersion` 重复),新增 `MySqlCapabilities`(`MySqlFeatures`):只 1 个位 `GroupByRollup`(8.0+,`ROLLUP()/CUBE/GROUPING SETS` vs `WITH ROLLUP`)。 +- 基线:**保守(未知 → None)**。理由:旧写法 `WITH ROLLUP` 在 5.7/8.0 都能跑,而 8.0 的 `ROLLUP()` 语法在 5.7 直接报错。顺带修了 `Version > new Version(8,0)` 的边界 bug(`8.0`、`8.0.0` 都判 false),现在用 `Major >= 8`。 +- `CustomMySqlAdapter` 的 `HandleSelectGroupBySegment` 简化:8.0+ 走 base;8.0 以下只有 `IsRollup` 时生成 `GROUP BY (...) WITH ROLLUP`,**CUBE / GROUPING SETS 不再抛 `NotSupportedException`**,走 base 生成后交给 MySQL 报错(按口径)。 +- MySQL 超时委托:`MySqlConnectionStringBuilder.ConnectionTimeout`(**uint**,要 cast;同类型另有 `DefaultCommandTimeout` → 再次印证"按键名试探分不清语义")。 +- 测试(158 用例):失败 9 / 通过 149。原因:4 个 CTE(5.7 无 CTE)、1 个 `Group_Cube_Test`(5.7 无 CUBE,旧代码在 5.7 下同样失败,只是异常类型从 `NotSupportedException` 变成 MySQL 语法错)、4 个既有表达式 bug(与另两个方言同名用例一致)⇒ 与本次改造无关。 + +### Oracle(按同一口径回审) +- 两个位都符合"有多套实现":`IdentityColumn`(IDENTITY vs 序列+触发器)、`JsonNativeType`(`JSON` 列 + `JSON()` vs `CLOB` + `FORMAT JSON`)→ 都保留。 +- 接入 `DetectVersion`:`OracleCapabilities.Start(factory, cs, specificVersion, detectVersion)`;`OracleProvider` 传 `generate.DetectVersion`。 +- `MapFeatures(Version? version, string? raw)` 的 **`raw` 参数无用已删**。 +- 顺带修边界:`Major >= 12 && Minor >= 1` 会漏掉 minor=0 的 12.1+ 版本 → 改为 `Major >= 13 || (Major == 12 && Minor >= 1)`。 +- 回归:194 用例 **18 失败 / 176 通过,与基线一致**;失败类型为 ORA-00054 资源正忙、ORA-12704 字符集不匹配、ORA-00904 `"B0"."UserId"`(CTE 别名,与 SqlServer 的 `'UserId'` 同源)等,均与能力位无关。 + +### 待议 +- MySQL 的**函数索引(8.0.13+)**:当前 `DbIndex.Columns` 只是列名字符串列表,框架没有函数索引生成点(`LightTableIndexAttribute(params string[] indexs)` 由用户手写),所以暂无能力位可用之处。若将来要支持"5.7 需要索引前缀长度"这类降级,再作为 `MySqlFeatures` 的新位加入。 +- 其余方言(PostgreSQL / KingbaseES / Dameng / Sqlite)尚未接入探测。 + +--- + +## 实测:`DetectVersion = true` 的真实开销(MySQL 5.7.44 本机,探针测完即删) + +| 观测点 | 耗时 | +|---|---| +| 探测开启 #1 构造 | 60.10 ms(**驱动首次初始化/JIT 占大头,与探测无关**) | +| 探测开启 #1 **首次读 ServerVersion** | **32.97 ms** ← 等一次建连,`5.7.44 [Probed]` | +| 探测开启 #1 次读 Features | 0.230 ms(这 0.23ms 是首次 JIT) | +| 探测开启 #1 读 Features × 100000 | 5.95 ms ⇒ **≈60 ns/次** | +| 探测开启 #2 构造(**同连接串**) | 0.16 ms | +| 探测开启 #2 首次读版本 | 0.000 ms | +| 探测关闭 构造 / 首次读版本 | 0.62 ms / 0.000 ms(`Assumed`) | +| 换连接串(不同 Database)构造 / 首读 | 1.40 ms / 5.96 ms | +| 裸建连(池化)建连+读版本(对照) | 5.66 ms | + +**结论**:稳态读取零开销(~60ns);那 30~40ms 只发生在**每个连接串在进程内第一次读取版本时**(= 等待一次建连)。 +同连接串的第二个 provider 构造 0.16ms、首读 0ms ⇒ 用户看到的「180ms → 220ms」是**每进程(每连接串)一次**,不是每用例。 +可消除该开销的既有手段:`SpecificVersion`(显式指定,零建连零等待)或 `DetectVersion = false`(走基线)。 +若想连这次建连也省掉,只有"用业务已打开的连接回填 ServerVersion"一路,但**首次生成的 SQL 会落在基线上**——SqlServer 的乐观基线在 2012 以下是错的(会生成 OFFSET/FETCH),故未采用。 + + + diff --git a/.workbuddy/memory/2026-09-18.md b/.workbuddy/memory/2026-09-18.md new file mode 100644 index 00000000..cc5cff18 --- /dev/null +++ b/.workbuddy/memory/2026-09-18.md @@ -0,0 +1,235 @@ +# 2026-09-18 + +## 抽取方言能力档案基类 `DbCapabilities` + +用户提出:三个方言的 `XxxCapabilities` 重复代码很多,想抽基类,但 **net462 不支持接口中的静态抽象方法** +(`static abstract` 需要 .NET 7+ 运行时),导致 `Start` / `PrepareProbeConnectString` 没法抽。 + +### 落地(`src/LightORM/Implements/DbCapabilities.cs`) +基类提供:`Baseline` / `ForVersion(Version)` / `Start(factory, cs, specificVersion, detectVersion)` ++ `ServerVersion` / `Version` / `Source` / `IsResolved` / `Features` / `Override` / `OpenBeforeRead`。 +方言只实现三样(**都是实例成员**): +- `protected abstract string ProbeTarget`(= `DbBaseType.Xxx.Name`,探测单飞键) +- `protected abstract string? PrepareProbeConnectString(cs, seconds)` +- `public abstract TFeatures MapFeatures(Version?)` + +### 关键手法(net462 下把静态工厂抽到基类) +`where TDatabase : DbCapabilities, new()`,静态工厂里 +`var metadata = new TDatabase();` —— 借这个**空实例**读出方言元数据(探测键 / 委托 / OpenBeforeRead), +`DbVersionProbe.Start(...)` 拿到结果后再写回同一实例返回。空实例只是元数据载体,成本可忽略。 +- 泛型基类内通过类型参数访问 `protected` 成员(CRTP)在 net462 下合法,未踩限制。 +- `Probe` 从 `public required` 改为 `protected { get; set; } = DbVersionProbe.None;`(不再需要 + `required`,用户之前加的 `RequiredMemberAttribute` 等 polyfill 可留作它用)。 +- 三个方言类现在各约 60~80 行(只剩枚举 + 三个 override)。 +- 用户原稿里的 `Create(DbVersionProbe)` + object initializer(`required Probe`)不可用:`new TDatabase()` + 需要 `new()` 约束,且方言私有构造会让约束无法满足 → 改为基类私有 `ForProbe(instance, probe)`。 + +### 验证 +- 编译:三个 provider **全部 TFM(含 net462、netstandard2.0)** 0 错误;三个测试项目 0 错误。 +- 行为:SqlServer `Select_Paging_Test` 1/1 通过;MySQL `Group_Rollup*` 3/3 通过 ⇒ 探测 → 能力位链路未变。 + +## 能力档案铺开到其余四个方言 + 基类拆两层 + +### 先实测四个方言的真实服务端版本串(写临时 MSTest 打印 `conn.ServerVersion`,跑完删除) +| 方言 | 驱动报告的 ServerVersion | 解析结果 | 备注 | +|---|---|---|---| +| Sqlite | `3.46.1` | 3.46.1 | 未 Open 也能读,且**不建库文件**(已实测) | +| PostgreSQL | `16.4 (Debian 16.4-1.pgdg120+1)` | 16.4 | 正则截前导数字段 | +| KingbaseES | `12.1` | 12.1 | **是 PG 兼容版本号**,不是 `V009R001C001B0025` ⇒ 可按 PG 分量判版本 | +| Dameng | `8.1.4.6` | 8.1.4.6 | `select banner from v$version` = `DM Database Server 64 V8` | + +连接串构造器(均已编译验证存在):`NpgsqlConnectionStringBuilder.Timeout`、 +`KdbndpConnectionStringBuilder.Timeout`、`DmConnectionStringBuilder.ConnectionTimeout`、SQLite 返回 null 不改写。 + +### 达梦 JSONB 实测(DM 8.1.4.6) +`CREATE TABLE t (C1 JSONB)` **能建成功**,但 `JSONB_VALUE` / `JSONB_QUERY` **函数不存在** +(`第1 行附近出现错误`);`JSON_VALUE` 正常。⇒ `JSONBackend.Binary` 在达梦不可用,但**与版本无关** +(只认类型名不认函数),属于"只有一种写法",故不登记能力位。 + +### 基类拆成两层(`src/LightORM/Implements/DbCapabilities.cs`) +- `DbCapabilities`:探测机制 + `ServerVersion`/`Version`/`Source`/`Baseline`/`ForVersion`/`Start`/`Override`; + `ProbeTarget` 抽象,`PrepareProbeConnectString` / `OpenBeforeRead` 改**虚成员给默认值**(前者返回 null)。 +- `DbCapabilities : DbCapabilities`:只加 `MapFeatures` + `Features`。 +- 理由:没有能力位的方言(PG/KES/Dameng)不该被硬塞一个空枚举。 + +### 四方言档案 +- `PostgreSQLCapabilities` / `KingbaseESCapabilities` / `DamengCapabilities`:**无能力位**(实测其 SQL 生成本就 + 没有按版本二选一的分支),只承载版本探测供诊断,并让 `SpecificVersion` / `DetectVersion` 语义一致。 +- `SqliteCapabilities`:`SqliteFeatures.Jsonb`(3.45+)+ `OpenBeforeRead => false`。 + `UseBinaryJson(JSONBackend)` = 用户选了 Binary **且**服务端支持 ⇒ 老库自动降级到 `json_*`。 + **AI 基线取 `Full`**(与 SqlServer 同为乐观):否则 `DetectVersion=false` 的 ToSql 场景会生成出与今天不同的 SQL。 +- 接线点:七个 provider 构造期 `Capabilities = XxxCapabilities.Start(factory, MasterConnectionString, generate.SpecificVersion, generate.DetectVersion)`, + 并把 `Capabilities` 作为公开属性暴露;SQLite 另把 capabilities 传进 `SqliteTableHandler` / `SqliteMethodResolver` / `CustomSqliteAdapter`。 + +### 验证(实测) +- `LightORM.sln` 全量构建 0 错误(含 net462 / netstandard2.0)。 +- SQLite:`Baseline→Full`、`3.44→None`、`3.45/4.0→Full`;`UseBinaryJson(old,Binary)=False`、`(modern,Binary)=True`、`(modern,Text)=False`; + 探测**不创建库文件**;`SqliteProvider.Create` → `Version=3.46.1 Source=Probed`;`DetectVersion=false` → `Source=Assumed, Features=Full`。 +- SQLite `~Json` 全部用例通过(未因 JSON 后端能力位回归)。 +- PG / KES / Dameng 三个 provider 实测 `Source=Probed` 且版本串正确解析。 +- **未跑**:Sqlite 全量(单个用例含 ~20s 底噪,全量 >15min 被工具超时打断;其间看到 `Group_Cube_Test` 因 + `no such function: CUBE` 失败——SQLite 本就不支持 CUBE,属既有失败,与本次改动无关)。 + +### 文档 +README `版本感知` 段 + `doc/项目大纲.md` 6.2 节:删掉已移除的 `JsonFunction`/`StringAgg` 能力位描述, +补上"只登记存在两套写法的能力"、两层基类骨架、七方言探测现状。 + +## ⚠️ 同日回退:上面"七方言都接入探测"被用户否掉(结论:只保留四个) + +用户质疑:**"如果方言没有能力位需要判断,为什么还要做版本探测?"** —— 这是对的,我上一轮的 +"统一诊断 + 统一 SpecificVersion/DetectVersion 语义"是弱理由: +- 探测的唯一目的是喂 `Features`;没有能力位 ⇒ 探测结果无处可用 ⇒ 纯粹白搭一次后台连库; +- `SpecificVersion` / `DetectVersion` 在无能力位的方言上**本来就没有语义**,忽略它是正确的,不算 bug; +- "统一诊断"用不着专门为此建连(要看版本随时可以自己开连接读)。 + +**最终形态**: +- `DbCapabilities` **合并回单个类**(拆两层只为容纳"无能力位方言", + 没有这种方言后,1 参基类会变成零实现的死抽象)。`PrepareProbeConnectString` / `OpenBeforeRead` + 保留为**虚成员带默认值**(默认不改写连接串、默认先 Open)——符合"不强塞方言不需要的声明"的口径。 +- **删除** `PostgreSQLCapabilities` / `KingbaseESCapabilities` / `DamengCapabilities`, + `git checkout --` 回退 PG / KingbaseES / Dameng 三个 provider 的构造改动(确认过这三处 diff 全是本次引入的)。 +- 接入探测的保留四个:SqlServer / MySql / Oracle / Sqlite。 +- 用户提的另一方案("实在要探测就塞一个默认空枚举,别让方言自己声明")**未采用**:没有使用场景, + 加了就是死代码;真出现"想探测但暂时没有能力位"的方言再补 `NoFeatures` 空枚举 + `MapFeatures` 默认实现即可。 + +### 回退后验证 +- `LightORM.sln` 全量构建 0 错误(含 net462 / netstandard2.0)。 +- Sqlite `SqlGenerate|JsonColumn_JsonSet_Update|CreateTable`:60 通过;5 个失败 + (`TestSelectOneTable` / `Select_Navigate_Where_Single` / `TestArrayAccess_List` / `TestRowNumberWindowFunc` / `InsertRange`) + = 历史记录里反复出现的**既存表达式/方言缺陷**(`2026-09-17.md` 已记:同批用例在 SqlServer/Oracle/MySQL 同时失败, + 栈在 `Utils/ResolveHelper.CreateGetter` 的 `Expression.Property` 与 `ExpressionResolver.VisitMember` 的 + `Expression.Equal` 类型不匹配),与能力位无关。 + +## 实现 SQLite 反向读表结构(`SqliteTableHandler` 三个 `NotImplementedException`) + +需求:`GetTablesSql()` / `GetTableStructSql(string table)` / `ParseDataType(ReadedTableColumn, out string)`。 + +### 实现(`src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs`) +- **列表**:`SELECT name AS TableName FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite\_%' ESCAPE '\' ORDER BY name`。 + `sqlite_%` 是引擎自己的表(`sqlite_sequence` 等),必须排掉。SQLite 无 schema 概念,`ReadedTable.SchemaName` 留空。 +- **结构**:走**表值函数 `pragma_table_info('t')`**,**不是** `PRAGMA table_info(t)` 命令 —— 后者不能出现在 + SELECT/子查询里,而"是不是 rowid 别名"必须**数同表主键列个数**(只有单列 INTEGER 主键才是别名), + 需要自连接。SQL:`CASE WHEN ti.pk>0 AND upper(trim(ti.type))='INTEGER' AND (SELECT COUNT(*) FROM pragma_table_info('t') p WHERE p.pk>0)=1 THEN 'YES' ELSE 'NO' END`。 + - `Nullable`:`notnull=1 OR pk>0` → `'NO'`(主键在 SQLite 里隐式 NOT NULL)。 + - `Comments` 恒 `''`(SQLite 无列注释);`DefaultValue` 取 `COALESCE(dflt_value,'')`; + `Length` = `instr(type,'(')>0` 时取括号内(`replace(substr(...), ')', '')`),否则空串。 + - 表名要进**字符串字面量** ⇒ `EscapeLiteral` = `Replace("'", "''")`。 +- **类型映射**:先剥掉 `(len)` 再 `Trim().ToUpperInvariant()` 走精确 `switch`(TINYINT/SMALLINT|INT2/INT|INTEGER|INT4/BIGINT|INT8/ + UNSIGNED BIG INT/BOOLEAN/REAL|DOUBLE/DOUBLE PRECISION/FLOAT/NUMERIC|DECIMAL/TEXT|CLOB|CHAR...|JSON/DATE/DATETIME/TIMESTAMP/ + TIME/BLOB|BINARY|VARBINARY/UUID|GUID|UNIQUEIDENTIFIER);未命中按 **SQLite 官方亲和性顺序**兜底 + (`INT` → `CHAR|CLOB|TEXT` → `BLOB` → `REAL|FLOA|DOUB`),最后 `object?` + `return false`。 + - 可空修饰来自 `column.Nullable`(`YES/Y/TRUE/1`);`byte[]` 不带 `?`(引用类型不加空标注)。 + +### 踩坑 +- **net462 无 `System.Range`/`System.Index`**:`declared[..paren]` 编译报 CS0518 ⇒ 改 `declared.Substring(0, paren)`。 +- **测试断言写错两次**(不是实现错): + 1. 以为 LightORM 写出的 `string` 列带 `NOT NULL` ⇒ 实际 `Nullable='YES'`(`SqliteTableHandler.Writer` 对非主键字符串不写 NOT NULL); + 2. `FLOATING POINT` 直觉该是浮点,实际按官方顺序 `POINT` 含 `INT` 先被整数族截胡 ⇒ **`int` 才是正确结果**, + 这条已回写成断言 + 代码注释,防止后人"优化"成浮点分支。 +- 表名带单引号的用例最初写成 `DROP TABLE "ZZ_QU''OTE"` —— `''` 只是**单引号字符串**里的转义,双引号标识符里直接写 `'` 即可。 + +### 验证 +- `LightORM.Providers.Sqlite` 全 TFM 构建 0 警告 0 错误(含 net462 / netstandard2.0)。 +- `test/LightORMTest.Sqlite/SchemaReadTest.cs`(类 `SqliteSchemaReadTest`)**5/5 通过**: + - `ReadBack_LightOrmTable`:ORM 建表 → 反读,列名/类型/主键/身份列/可空/长度全对,且列表里无 `sqlite_` 表; + - `ReadBack_RawTable`:17 种声明类型原生建表 → 类型映射逐一核对(`VARCHAR(50)→string` + `Length="50"`、 + `BIGINT→long`、`DECIMAL(18,2)→decimal?`、`DOUBLE PRECISION→double?`、`UUID→Guid?`、 + `WIDGET→object?`/`false`); + - `TableName_With_Quote`:表名含 `'` 不炸; + - `ParseDataType_Empty` / `ParseDataType_Affinity_Fallback`(含上面那条 INT 优先的回归断言)。 +- 顺手把临时脚手架 `ZZSchemaReadTest.cs` 转成正式回归测试 `SchemaReadTest.cs`(`ZzSchemaUser` → `SchemaReadUser`), + 而不是删掉:它覆盖的是本次新写的代码路径,值得留在套件里。 + +### 顺带确认 +- 七个 provider 的 `TableHandler` 里,当时**只剩达梦**还为这三个方法抛 `NotImplementedException`; + KingbaseES 早已有 PG 风格实现(`information_schema` + `col_description`),SqlServer / MySql / Oracle / PostgreSQL / Sqlite 均已实现。 + (达梦的已在同日稍后补上,见下节。) + +## 补上达梦反向读表结构(`DamengTableHandler` 三个 `NotImplementedException`) + +### 先用四轮探针把达梦的元数据摸干净(临时 MSTest + `DmConnection` 直连,跑完删除) + +**第一轮**建表直接失败,报错定位在语句结尾、看不出哪列 —— 逐列重试才发现 +**`BOOLEAN`("无效的数据类型")和 `UUID`("非法的基类名")在达梦不能建列**。其余 40 种类型名全部支持。 +教训:建表失败先**逐个类型单独建表**定位,别在一张大表里猜。 + +**第二轮**(全类型表 + 元数据) +- `USER_TAB_COLUMNS` **可用**,但**没有 `IDENTITY_COLUMN` 列**(报"无效的列名"), + 而且 IDENTITY 列的 `DATA_DEFAULT` 也是空的 ⇒ Oracle 那套判自增的路子走不通。 +- 列注释在 `USER_COL_COMMENTS`(未注释列给空串);主键在 `USER_CONSTRAINTS`/`USER_CONS_COLUMNS` ✓ +- 最后靠 `SYSOBJECTS`(TYPE$='SCHOBJ', SUBTYPE$='UTAB') 找到表 ID → `SYSCOLUMNS`, + 发现 **`INFO2` 的 bit0 就是自增标记**(IDENTITY 列=1,普通列=0)。 +- `DATA_SCALE` 并不是纯小数位:`JSON/JSONB=16384`、`NVARCHAR2/NVARCHAR=7`、`NCHAR=8`、`TIMESTAMP=6`。 + ⇒ 数值分支必须再用 `TYPE$ IN ('DECIMAL','NUMERIC','NUMBER','DEC')` 限定。 + +**第三轮**(关键的两个坑) +1. **`USER_TAB_COLUMNS.DATA_LENGTH` 对 `NVARCHAR2` 给的是字节数**:`NVARCHAR2(64)` → 128,且 `CHAR_LENGTH` 为 0 + (而 `NVARCHAR(64)` → CHAR_LENGTH=64,`NCHAR(10)` → 10)。 + **`SYSCOLUMNS.LENGTH$` 才是字符数**(给 64)⇒ Length 全改用 `s.LENGTH$`。 + 这条直接决定了 LightORM 默认 `UseUnicodeString=true` 建的表(NVARCHAR2)能不能读对长度。 +2. **JSON / JSONB 物理存成 `BLOB`**(`DATA_TYPE='BLOB'`),与真 BLOB 无法靠类型名区分。 + +**第四轮**(收口 JSON) +- 发现达梦有官方视图 **`USER_JSON_COLUMNS(TABLE_NAME, COLUMN_NAME, FORMAT, DATA_TYPE)`**, + 实测 3 个 JSON 列全被收录、普通 BLOB 不在其中。 +- 但最终**没采用它**:改用 `SYSCOLUMNS.SCALE = 16384`(达梦给 JSON 的 BLOB 打的内部子类型标记,普通 BLOB=0; + 达梦十进制标度最大 38,不可能自然取到 16384)。理由是失败模式更温和 —— + 视图不存在会让**整条 SQL 报错、功能全废**,而 16384 失效最多是 JSON 列被当 `byte[]`。 +- 同一轮把**最终 SQL 原样预演**通过,Length/Nullable/PK/Identity/Comments/默认值一次性全对。 + +### 实现(`src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs`) +- 列表:`SELECT TABLE_NAME AS TableName FROM USER_TABLES ORDER BY TABLE_NAME`。 +- 结构:`USER_TAB_COLUMNS` 主表 + `USER_COL_COMMENTS` / `USER_CONS_COLUMNS`+`USER_CONSTRAINTS` / + `SYSOBJECTS`+`SYSCOLUMNS` 四个 `LEFT JOIN`(挂不上只降级,不丢列)。 +- `DataType`:`CASE WHEN DATA_TYPE='BLOB' AND s.SCALE=16384 THEN 'JSON' ELSE DATA_TYPE END`。 +- `Length`:LOB 类 → `''`;数值类 → `"精度,标度"`;其余 `s.LENGTH$ > 0` 才给值,否则 `''`。 +- `ParseDataType`:达梦 `DATA_TYPE` 是**纯类型名**(无括号),定点细分只能靠 `column.Length`; + `NumericType` 带逗号 → decimal,无精度信息 → **decimal**(裸 `NUMBER` 是浮点语义); + `FLOAT → double`(达梦 FLOAT 是 8 字节双精度)、`REAL → float`;`BIT → bool`;`JSON/JSONB → string`。 +- 与 writer 的不对称是刻意的,注释里写明了:`bool` 写 `CHAR(1)`、`Guid` 写 `CHAR(36)`, + 读回一律 `string`(真 `CHAR(1)` 多存 `'Y'`/`'N'`,猜 bool 会反序列化失败)—— 口径与 SQLite 一致:**不逆向猜测 writer 的私有约定**。 + +### 验证 +- `LightORM.Providers.Dameng` 三个 TFM(net462 / net8.0 / net10.0)构建 **0 警告 0 错误**。 +- 新增 `test/LightORMTest.Dameng/SchemaReadTest.cs`(`DamengSchemaReadTest`)**4/4 通过**: + `ReadBack_LightOrmTable`(ORM 建表含 JSON 列 → 反读,ID 识别为 INT/主键/自增/非空、 + NAME 为 `NVARCHAR2` 且 Length=**128 字符**而非 256 字节、MONEY `33,3`→`decimal?`、 + DATA 从 BLOB 改写回 `JSON`)、`ReadBack_RawTable`(13 种原生类型逐一核对)、 + `ParseDataType_NumericPrecision`、`ParseDataType_Empty_And_Unknown`。 +- 回归:达梦 `DbMethodTest` + `CreateTableTest` **3/3 通过**。 +- ⚠️ `dotnet build LightORM.sln` 报 `MSB3202: 未找到 test\TestProject1\TestProject1.csproj` + —— **sln 里这条项目路径是坏的(项目实际在仓库根的 `TestProject1/`,不在 `test/` 下),与本次改动无关**, + 按项目单独构建不受影响。顺手记一笔,别被它误导。 +- 三处 TFM 事实纠正:`src/SupportedFrameworks.props` 现在是 **net462;net8.0;net10.0**, + **netstandard2.0 已经移除**(旧记录里还有,属过时信息)。 + +## 分批提交(10 个 commit) + +用户要求把「版本检测 + 反向读表」这一批改动分批提交到本地。按 +**基础设施 → 各方言接入 → 反向读表 → 仓库整理 → 文档/版本号/记忆** 的顺序拆成 10 个提交, +每个提交都刻意做成自洽可编译单元 —— 同一次方言接入必须捎上引用它的测试与 DatabaseUtils, +否则中间态编译不过(例:`OracleTableOptions.OverVersion` 删掉后,`OracleTableHandler.Writer.cs` 必须同 commit)。 + +| # | commit | 内容 | +|---|---|---| +| 1 | `5f4b63dd` | 版本探测基础设施(DbVersionProbe / DbServerVersion / DbCapabilities / TableOptions / polyfill) | +| 2 | `5e85c883` | SqlServer 接入(含 UseSqlServer 签名变更 → 测试 + DatabaseUtils 同步) | +| 3 | `2b850ad5` | MySQL 接入 | +| 4 | `38fdeab1` | Oracle 接入 + IDENTITY 列 DDL 修正 | +| 5 | `4b8b696f` | SQLite 接入 + 反向读表结构(含共享测试的 ResolveContext 改造) | +| 6 | `a2503ae4` | 达梦反向读表结构 | +| 7 | `1a4008c5` | 移除 test/TestProject1 并同步 slnx | +| 8 | `397f7a5c` | README / 项目大纲文档 | +| 9 | `bd403fa8` | 版本号升 2026.09.18.1 + test.db | +| 10 | `adb44896` | 工作区记忆 | + +### 提交时的两个坑 +- **假改动**:`src/LightORM/Utils/ExpressionResolver.cs` 只是 CRLF/LF 行尾差异(`git diff --numstat` 无输出), + `git update-index --refresh` 清不掉 ⇒ 先 `cp` 备份、再 `git checkout --` 还原、`cmp` 确认内容等价。 + 这个仓库的 autocrlf 会让"只看 stat 缓存"的文件一直显示 `M`。 +- **⚠️ 两个回归测试文件(Sqlite/Dameng 的 `SchemaReadTest.cs`)在提交前被用户主动删除**, + 用户明确说"不用重建"⇒ 提交 5/6 里**只有实现、没有测试**。别在后续按"反向读表已有回归测试覆盖"来推断。 + +### 既存问题(已核实最后改动早于本次提交,与本次无关) +- `test/BenchmarkTest/StringBuilderPoolTest.cs` 引用已不存在的 `Ado` 扩展 ⇒ `dotnet build LightORM.slnx` 报 4 个错误。 +- `LightORM.sln`(旧格式)仍指向已删除的 `test/TestProject1/TestProject1.csproj` ⇒ `MSB3202`;只有 `.slnx` 被同步更新了。 diff --git a/.workbuddy/memory/MEMORY.md b/.workbuddy/memory/MEMORY.md index a2f93182..c71d601e 100644 --- a/.workbuddy/memory/MEMORY.md +++ b/.workbuddy/memory/MEMORY.md @@ -1,133 +1,133 @@ # LightORM 项目长期备忘 -## 构建环境(关键) - -WorkBuddy bash 环境缺 `APPDATA`/`PROGRAMDATA`/`ProgramFiles` 环境变量,导致 dotnet restore 报 `Value cannot be null. (Parameter 'path1')`。运行 dotnet 命令前必须: - -```bash -export APPDATA="C:\Users\Marvel\AppData\Roaming" PROGRAMDATA="C:\ProgramData" && env "ProgramFiles=C:\Program Files" "ProgramFiles(x86)=C:\Program Files (x86)" dotnet <命令> -``` - -NuGet 本地源:`E:\GitRepositories\LocalNuget`(用户 NuGet.Config 里的 "local" 源),全局包目录 `E:\Nuget\.nuget\packages`。 - -补充(2026-09-07):bash 沙箱还会吞掉 dotnet.exe 的 stdout(exit 0 但无任何输出);dotnet 命令优先用 PowerShell 工具执行(同样需补 APPDATA/PROGRAMDATA)。反编译用 `C:\Users\Marvel\.dotnet\tools\ilspycmd.exe`。 - -补充(2026-09-10):PowerShell 工具偶尔完全无输出(连 `Write-Output` 都不回显),此时改用 bash + 文件重定向,稳定可用:`cd /e/GitRepositories/LightORM && export APPDATA="C:\Users\Marvel\AppData\Roaming" PROGRAMDATA="C:\ProgramData" && env "ProgramFiles=C:\Program Files" "ProgramFiles(x86)=C:\Program Files (x86)" dotnet test ... > out.txt 2>&1; echo "EXIT=$?"`,再用 `grep -a` 读(中文日志需 `-a`)。`--no-build` 前必须确保**目标项目自己**刚 build 过——共享项目 LightORMTest.dll 在各自 bin 下是独立副本,只 build 别的 provider 项目不会刷新它,`--no-build` 会跑到旧代码。 - -补充(2026-09-15):**bash 工具的 PATH 会丢失** —— 初始 PATH 缺 `/usr/bin`,`ls`/`grep`/`head`/`dirname` 全报 command not found,且 shell 状态在两次调用之间不保留。每条 bash 命令前都要加 `export PATH="/usr/bin:/bin:$PATH"`。另:**不要在此环境用 `git stash`** —— `git stash push` 在本仓库会失败并留下残缺的 `refs/stash`(`stash show/drop` 报 "not a stash-like commit"),且使其后 `git status`/`git log`/`git diff` 因 submodule `src/GenShared`(gitdir `.git/modules/src/GenShared` 缺失)报 `fatal: not a git repository`;清理残留引用用 `git update-ref -d refs/stash`。该 submodule 的本地完整副本在 `E:\GitRepositories\MT.Generators.Shared`。另外此环境对 `.git` 的可见性可疑 → **该判断已作废**。2026-09-15 17:45 用 PowerShell(独立于 bash 沙箱)`Test-Path` 复核,确认仓库是**真实损坏**,不是隔离视图。要点见 2026-09-15 日志:① 缺失 4 commit + 5 tree + 103 blob,**只影响 09-14/15 的近期本地提交**,历史分支(36 个 ref、2 个 pack `verify-pack` 通过)完好;② `refs/heads/master` 的 `3ef2783b` 在 GitHub 同名存在,`git fetch github` 可恢复;③ `.git/modules/src/GenShared` 是**被外部工具删到回收站**(17:24:52:xx),可还原;④ 回收站里**确实有** `.git\objects` 条目(被前一次的判断误否,见"恢复经验")。git 本身从不使用回收站(不用 Shell API)⇒ 删除来自外部 Git GUI,不是 git 命令。 -**排查经验**:判断"对象是否真缺失"必须用**第二个独立工具**(PowerShell `Test-Path`)交叉验证,别只信 bash 沙箱结论;回收站 `$I` 元数据可给出**精确到秒的删除时间与原始路径**(Python 在沙箱里读不到 `$RECYCLE.BIN`,PowerShell 可以)。**同一仓库同时开着 SourceTree / UGit / VS 的 Git 工具是高危操作,动 git 前先关掉它们。** - -补充(2026-09-15 18:20,**git 对象损坏已恢复**,方法可复用): -- **不要用回收站记录里的"名字"判断内容**:`$I` 里的原始路径在控制台会被截断(只显示到 `…\.git\objects\`),据此筛选会得出"回收站里没有 objects"的错误结论。**直接用内容判定**。 -- **内容级恢复法**(`%TEMP%\recover_git_objects.ps1`,PowerShell,因为沙箱禁止 Python 读 `$RECYCLE.BIN`):枚举 `$R*` 文件 → 按 zlib 头筛(`0x78`+`01/5E/9C/DA`)→ `DeflateStream` 跳 2 字节头解压 → 以 `blob `/`tree `/`commit ` 开头即为 git 对象 → 对**解压后内容**求 SHA-1 → 目标 `.git\objects\aa\bbbb…` 不存在则复制(**只增不改,天然安全**)。本次一次恢复 **382 个对象**(178 blob/163 tree/41 commit)。 -- **坏 ref 会阻断 `git fetch`**(`fatal: bad object ` + `did not send all necessary objects`)。处理:把坏 ref 文件**临时移出 `refs/`**(如移到 `.git/refs-disabled/`,可逆不删数据)再 fetch,取回后用 `git update-ref` 重建。 -- **本地丢失的 commit 可能躺在远端的非分支 ref 上**:`refs/heads/master` 的 `3ef2783b` 在 GitHub 同名分支;`refs/heads/测试用例` 的 `321adb36` 只在 **`refs/pull/42/head`**(PR 头)。取 PR 头:`git fetch github +refs/pull/42/head:refs/remotes/github/pr-42`。 -- **本环境 ssh 被沙箱策略拒绝**(`C:\Users\Marvel\.ssh\*` blocked),submodule 重克隆需让用户在本地终端执行或用本地副本 `E:\GitRepositories\MT.Generators.Shared`。 -- **bash 沙箱对 `.git` 的视图会滞后**:unsandboxed 侧(PowerShell / escalate 过的命令)新建的目录,sandboxed 侧 `ls`/`git` 看不到;反之 sandboxed 看不到 ≠ 磁盘上没有。涉及 `.git` 下新建/删除,一律用 PowerShell 交叉验证。 -- **submodule gitdir 重建步骤**(`.git/modules/src/GenShared` 被删时):`git submodule update --init` 会因工作区目录非空而失败(`destination path already exists and is not an empty directory`),需手动克隆到 gitdir,再 `git --git-dir= config core.worktree ../../../../src/GenShared`,最后 `git -C src/GenShared checkout `。 - -跑测试的命令:`dotnet test test/LightORMTest.Sqlite/LightORMTest.Sqlite.csproj --filter "FullyQualifiedName~Update|FullyQualifiedName~Json" -v n`;测试输出里会带 `SQL:` + `参数:` 调试块,定位生成 SQL 问题非常有效。SqlGenerate 目录下的用例只 `Console.WriteLine` 不连库,PostgreSQL 项目也能本地跑(`--logger "console;verbosity=detailed"` 才看得到 SQL)。 +## 构建 / 命令环境(关键) +- bash 沙箱:**每条命令前加** `export PATH="/usr/bin:/bin:$PATH"`(初始 PATH 缺 /usr/bin,shell 状态不跨调用保留)。 +- dotnet 缺环境变量 → restore 报 `Value cannot be null (path1)`。补: + `export APPDATA="C:\Users\Marvel\AppData\Roaming" PROGRAMDATA="C:\ProgramData" && env "ProgramFiles=C:\Program Files" "ProgramFiles(x86)=C:\Program Files (x86)" dotnet ` +- dotnet 输出会被沙箱吞掉(PowerShell 工具偶尔也完全无回显)→ **重定向到文件最稳**:`dotnet test ... > out.txt 2>&1; echo "EXIT=$?"`,再 `grep -a`(中文日志必须 `-a`)。 +- `--no-build` 前必须**刚 build 过目标项目自己**(共享 LightORMTest.dll 在各 provider bin 下是独立副本)。 +- NuGet:本地源 `E:\GitRepositories\LocalNuget`;全局包目录 `E:\Nuget\.nuget\packages`。反编译 `C:\Users\Marvel\.dotnet\tools\ilspycmd.exe`。 +- **不要用 `git stash`**(本仓库会留残缺 `refs/stash`,并让 status/log/diff 因 submodule `src/GenShared` 报错);清理用 `git update-ref -d refs/stash`。submodule 本地完整副本在 `E:\GitRepositories\MT.Generators.Shared`;ssh 被沙箱拒绝,重克隆需用户本地执行。 +- 判断"文件/对象是否真的缺失"要用**第二个独立工具**(PowerShell Test-Path)交叉验证,别只信 bash 沙箱。回收站可恢复 git 对象:枚举 `$R*` → zlib 头卷积 → 解压后以 `blob `/`tree `/`commit ` 开头即为对象 → 对解压内容求 SHA-1 → 缺失则复制(只增不改)。**同一仓库同时开 SourceTree / UGit / VS 的 Git 工具是高危。** ## 项目约定 - -- LightORM 多目标框架:net462;netstandard2.0;net8.0;net10.0;版本号集中管理在 `src/versions.props`。 -- 源生成器:`LightOrmTableContextGenerator`(`[LightORMTableContext]`)+ `LightOrmExtensionGenerator`;使用生成器的项目必须 `enable`,否则生成代码级联报 CS0535/CS0738。 -- `AddLightOrm` 扩展在 namespace `LightORM`(IoCExtensions.cs)。 -- DatabaseUtils(WPF Blazor Hybrid)→ DatabaseUtils.Avalonia(net10.0 + MVVM Toolkit)迁移进行中:阶段一(基础设施)+ 阶段二(纯逻辑层)已完成,2026-09-06。剩余:阶段三 ViewModel、阶段四 View、阶段五回归。迁移映射与计划见 2026-09-06 日志。 - -## JSON 列与方言约定(2026-09-11) - -### 架构(方案 A:序列化下沉到方言 binder) -- 框架**不再预序列化** json 参数:`DbParameterValue` 携带**原始 CLR 值**,序列化与驱动类型化统一下沉到 `IDatabaseParameterBinder.BindParameter(parameter, column, value)`。 -- `src/LightORM/Utils/JsonParameterHelper.cs`:`Serialize(object?)`(走 `ExpressionSqlOptions.Instance.Value.GetJsonHandler()`)+ `IsCompositeJsonValue(Type|object)`(标量白名单 string/char/数值/Guid/DateTime/TimeSpan/byte[]/Uri/Version/object,其余视为复合)。 -- `CustomDatabaseAdapter` 实现 `IDatabaseParameterBinder` 并给出**默认 json 绑定**(json 列 → `Serialize` + `DbType.String`),所有方言(含第三方)继承即得。 -- `InsertBuilder` / `UpdateBuilder` / `BatchSqlInfoExtensions` 中的 json 预序列化已全部移除,json 列与普通列同路。 -- **缓存约束**:`Resolve` 的 cache key 只有 `(SqlAction, Hash, Depth)`、**不含值** → SQL 侧的"形状分支"必须由**表达式结构**(成员类型)决定,不能用运行时值。 - -### 各方言"按 JSON 解析文本参数"的写法(否则双重编码) -| 方言 | 路径更新值参数 | 备注 | -|---|---|---| -| PG / KingbaseES | `@p::JSONB`(binder 另声明 jsonb) | 恒等 cast | -| SQLite | `JSON(@p)` | `json_set` 对 TEXT 按字面量处理,必须包装 | -| SqlServer | 复合 `JSON_QUERY(@p)` / 标量传**原生值** | 无 `JSON()`;标量文本抛 Msg 13609;需生成期分流 | -| MySQL | `CAST(?p AS JSON)` | **5.7.44 实测 17/17 通过**;整列**必须** `col = ?p`(见下"NULL 陷阱") | -| **Dameng(DM8)** | `CAST(:p AS JSON)` | 实测对字符串/对象/数组/数字/布尔/null **一律正确**,无需分流;binder 用框架默认 | -| Oracle | `JSON(:p)`(包在 `JSON_TRANSFORM` 的 SET 里) | **21c XE 实库测试已通过**(2026-09-17) | - -### 各方言"读取路径成员取值"的写法(2026-09-17 新增,统一走 `IsCompositeJsonLeaf`) -| 方言 | 末级标量 | **末级复合(对象/数组)** | 机制 | +- 多目标框架 **net462;net8.0;net10.0**(`src/SupportedFrameworks.props`;**netstandard2.0 已移除**,别再按旧记录找它);版本号集中在 `src/versions.props`。 +- 源生成器:`LightOrmTableContextGenerator` + `LightOrmExtensionGenerator`;用生成器的项目必须 `enable`。 +- `AddLightOrm` 在 namespace `LightORM`(IoCExtensions.cs)。 +- 驱动:MySqlConnector 2.6.0、Microsoft.Data.SqlClient 7.0.1(net462 走 System.Data.SqlClient)。 +- 测试命令:`dotnet test test/LightORMTest.Sqlite/LightORMTest.Sqlite.csproj --filter "FullyQualifiedName~Update|FullyQualifiedName~Json" -l "console;verbosity=detailed"`。SqlGenerate 目录用例只 `Console.WriteLine` **不连库**(离线可跑)。 +- DatabaseUtils(WPF) → DatabaseUtils.Avalonia 迁移:阶段一/二已完成,剩 ViewModel / View / 回归。 + +## 方言能力开关现状 +| 方言 | 现有手写开关 | 位置 | 影响 | |---|---|---|---| -| Oracle | `JSON_VALUE(col,'$.p')` | `JSON_QUERY(col,'$.p')` | **已修**,21c XE 实跑通过 | -| SqlServer | `JSON_VALUE(...)` | `JSON_QUERY(...)` | **已修**,无实例未实测 | -| MySQL | `col->>'$.p'` | 同左(`->>` 对对象返回文档文本,本身就对) | 无需改 | -| PostgreSQL | `(col->>'p')::TARGET` | 同左(数组用 `col->N`) | 无需改 | -| **KingbaseES** | `(col->>'p')::TARGET` | 同左(与 PG 同源) | **无需改,实测通过**(2026-09-17) | -| SQLite | `json_extract(...)` | 同左 | 无需改,实测通过 | -| Dameng | `JSON_VALUE`(Binary 后端起为 `JSONB_VALUE`) | **未改,待验证**(实例未启动,且不确定 DM8 是否有 JSON_QUERY) | — | - -- 判定函数:`JsonParameterHelper.IsCompositeJsonLeaf(JsonColumnContext)`(`src/LightORM/Utils/JsonParameterHelper.cs`)。 - 取值口径 = `Members` 栈(枚举顺序即 Pop 顺序)的**最后一个元素**,即 json 路径最内层;末级无成员信息 - (`Arr[1]`/`Lst[0]` 这类纯索引路径)时退回列本身的 CLR 类型再取元素类型;无法判定按标量,与 binder 的保守策略一致。 - **只看表达式结构 + 列元数据,不看运行时值 → 与 `Resolve` 表达式缓存兼容。** -- 相关用例:`ExecutionTest.JsonColumn_CompositeMember_Projection`(匿名投影 `new { N = j.Data.NestJson }` / - `new { I = j.Arr[1] }` / `new { L = j.Lst[0] }`);SQL 探针 `SqlGenerate.SelectSql_Json.TestJsonCompositeLeafMemberRead`。 -- **投影形状**:取复合末级成员时,**匿名投影与非匿名目标类型都支持**。非匿名(`ToListAsync(j => j.Data!.NestJson)`) - 靠 `ExpressionBuilder.CreateCustomEntity` 开头的 `if (ContainsJsonType(targetType)) return GetTargetJsonExpression(..., 0, targetType);` - —— 该形状 SQL 只 SELECT 一列,第 0 列即 json 表达式。`ContainsJsonType` 查的是 `JsonMaps`(只装 `[LightJsonMap]` 的列类型, - 经 `ColumnInfo.AddJsonTypeMap` 注册),实体类型不在其中,故不会误伤普通实体映射。2026-09-17 用户改动 + SQLite/Oracle 实测通过。 - - -### MySQL / MySQL 特有陷阱 -- **`JSON_SET` 首参为 NULL 时整体返回 NULL** → MySQL 下整列更新**不能**写成 `JSON_SET(col,'$',val)`:列一旦被 `SetNull`/`Set(col,null)` 置空,值就再也写不回去(静默丢失,不报错)。整列一律 `col = ?p`(JSON 文本写 JSON 列时 MySQL 自动解析)。 -- `SqlFn.JsonSet(路径, 值)` 的值在 MySQL 侧是**原始 CLR 值**(字符串 → JSON 字符串、数字 → JSON 数字),与 PG 需自行传 JSON 文本(`"\"NewName\""`)的约定不同,跨库用例按 `DbType` 分支。 -- MySQL `ON DUPLICATE KEY UPDATE` 受影响行数按"插入 1 / 更新 2"计 → 断言需 `DbType == MySql` 分支(`ExecutionTest.cs` 既有约定)。 -- 本机 MySQL 是 **5.7.44**:无 CTE(`WITH ... AS` 直接语法错误)、无窗口函数、CUBE/GROUPING SETS 抛 `NotSupportedException`(`MySqlTableOptions.Version` 默认 null → `over8=false`)。MySQL 全量 144/155,失败的 11 个全部由此而来,与 json 无关。 - -### 其他 -- **KingbaseES 陷阱(整列更新)**:`JSONB_SET(col::JSONB,'{}',@p::JSONB)` **不能**当整列赋值用 —— - 空路径不保证替换整个文档(实测列**非空**时值也写不进去),首参为 NULL 时又整体返回 NULL。 - 整列一律 `col = @p::JSONB`。`CustomKingbaseESAdapter.HandleJsonColumn` 原先漏了 PG 里 - `HasIndexInfo()` 的二分(UPDATE 分支直接生成 JSONB_SET),2026-09-17 已修。 -- **`DbBaseType` 是 record(按 `Name` 值相等)**:Kingbase 的 `Name` 是 `"KingbaseES"`,故 - `DbType == DbBaseType.PostgreSQL` 为 **false**。测试里凡"PG 与 KingbaseES 同源"的分支(如 - `SqlFn.JsonSet` 的路径 `'{a,b}'` 与值 `"\"text\""` 格式)要写成 - `DbType.Name is "PostgreSQL" or "KingbaseES"` —— `ExecutionTest.JsonColumnCases.cs` 已如此。 -- **例外**:`SqlFn.JsonSet(path, value)` 走 `XxxMethodResolver.JsonSet`,值参数是**用户原始值、不序列化**(不经 HandleJsonColumn)→ 不能加 JSON 包装;PG 侧需用户自己传 JSON 文本(测试里手写 `"\"NewName\""`)。 -- json 列**整列**更新(`Set(j => j.Data, obj)` / `UpdateColumns`):各方言统一 `col = @p`,读回反序列化,对称。 -- **达梦**:列类型默认 `JSON`(原生,长度 >320000 走 CLOB);`JSONBackend.Binary` 在本机 DM8 **不可用**(`JSONB_VALUE` 不存在、`JSONB_SET` 拒绝 `'$.a'`),用默认 `Text`。 -- **达梦实例可用**:`localhost:5236`(LIGHTORM_TEST/LIGHTORM_TEST/DAMENG),`LightORMTest.Dameng` 可实跑;多测试类并发建连时 DM 会报 `6001 每个套接字地址只允许使用一次`(环境/连接数问题,非代码 bug),稍等重跑即恢复。 -- **KingbaseES 实例可用**:docker 容器 `kes`(镜像 `kingbase_v009r001c010b0004_single_x86:v1`,端口 **54321**), - `database_mode = oracle`(启动未设 DB_MODE,V9 默认 oracle)。**该模式不影响 json**:`jsonb` 类型、`->`/`->>`、 - `JSONB_SET`、`::` cast 均可用,json 用例 **18/18 通过**。容器内免密查配置: - `docker exec -u kingbase kes bash -lc "ksql -U kingbase -d test -c 'show database_mode'"`。 - 测试项目 `test/LightORMTest.KingbaseES/`(net10.0 + MSTest 4.0.2),注册 `DbBaseType` 用 - `KingbaseESProvider.KingbaseEs`(**不是** `Oracle`);全量 **99/99 通过**(2026-09-17)。 -- **KingbaseES 建表:字符串列一律映射成 `TEXT`**(`Utils.FormatType.TransformType` 的兜底分支), - 所以 `[LightColumn(Length = n)]` 的长度约束必须靠 `KingbaseESTableHandler.Writer.BuildColumn` 里的 - `dataType == "TEXT" && column.Length.HasValue → VARCHAR(n)` 补回来,否则约束**静默丢失** - (`Transaction_Atomicity_Test` 正是靠长度溢出触发回滚,曾因此失败)。 -- **Oracle 实例可用**:`localhost:1521/XE`(`lightorm_test`/`lightorm_test`,写在 `test/LightORMTest.Oracle/GlobalUsings.cs` 的 `ConnectString`),**Oracle 21c XE**。21c 才有原生 `JSON` 类型与 `JSON_TRANSFORM`,实库测试已通过;≤19c 建表即失败。 -- 定位 json 问题的高效手段:先写**方言语义探针**(Python `sqlite3` / `sqlcmd` / DmProvider `DmCommand`)验证各 JSON 函数对各类参数的行为,再改框架,比反复改 C# 跑测试快得多。 - -## 测试基础设施(2026-09-17 实测) - -- **六台容器常驻**:`dm8` 5236 / `kes` 54321 / `oracle21xe` 1521 / `mysql` 3306 / `pgsql` 5432 / `mssql` 1433。 - `--list-tests` 实测用例数:Dameng **270** / Oracle 194 / Sqlite 168 / KingbaseES 100。 -- **每个用例前都会重建整个 schema**:`test/LightORMTest/ResultTest/ExecutionTest.InitData.cs` 的 - `[TestInitialize] InitDatas()` = 10 张表 DROP + CREATE + 8 张表 FullDelete + 重插种子数据。 - MSTest 的用例耗时**包含 TestInitialize**,所以每个用例都有几秒底噪 —— 写"某用例为何很慢"的分析时别漏了这项。 -- **达梦测试慢的两个真原因**(不是查询、不是驱动): - 1. 达梦 DDL 贵:单次 init ≈ **4.8 s**(其中 CREATE 段 3.9 s、裸 DROP 220 ms/张), - Kingbase 同项只有 **0.57 s**;DM 的查询本身只要 3–10 ms。 - 2. 建表语句被拆成逐条发送:`DamengTableHandler.Writer` 对 `CREATE TABLE`/每条 `COMMENT`/每条 `INDEX` - **各 yield 一次**(10 张表 = **131 条语句 = 131 次往返**),而 PG/Kingbase 用 `StringBuilder.AppendLine` - 拼成一段、**每表 yield 一次**(≈10 次往返)。 -- **达梦 DDL 的批量化不可行(已实测,别再试)**:裸 `DmConnection` 跑 8 表 × [1 建表 + 10 注释 + 4 索引] - = 120 条语句,逐条 **3412 ms**,且 **CREATE 25.6ms/条、COMMENT 25.28ms/条、INDEX 24.63ms/条** —— - 单条成本与语句内容无关 ⇒ 是"每条 DDL 自带一次提交/落盘"的固有代价。 - ① `;` 分隔的多语句命令被 DM 拒绝(`语法分析出错`);② Oracle 风格匿名块 - `BEGIN EXECUTE IMMEDIATE '…'; … END;` 语法能过但同一工作量要 **23397 ms(慢 ~7 倍)**。 - ⇒ 唯一可控手段是**减少 DDL 条数/次数**(如把 schema 重建移出 `[TestInitialize]`)。 -- **重复的测试类**:`LightORMTest.Dameng` / `PostgreSQL` / `SqlServer` 项目里同时存在 - `ResultTest/ExecutionTest.cs` 与 `SelectResult.cs`,**两者都继承共享 `ExecutionTest`(100 个用例)** - → 整套共享套件在这些库里跑两遍。Sqlite / Oracle / MySql / KingbaseES 只有一份。 +| SqlServer | ~~`SqlServerVersion`(V1/Over2012/Over2017)~~ **已删除**,改由版本推导 | `SqlServerCapabilities.Features` ← provider 构造期 `Start(...)`;adapter / MethodResolver 均接收 capabilities | `OffsetFetch`(2012+) 分页、`TrimFunction`(2017+) | +| MySQL | ~~`MySqlTableOptions.Version`~~ **已删除**,改由版本推导 | `CustomMySqlAdapter` ← `MySqlCapabilities.Features` | `GroupByRollup`(8.0+):`ROLLUP()/CUBE/GROUPING SETS` vs 旧式 `WITH ROLLUP`;CUBE/GROUPING SETS 低版本交给数据库报错 | +| Oracle | ~~`OracleTableOptions.OverVersion`~~ **已删除**,改由版本推导 | `OracleTableHandler.UseIdentityColumn` ← `OracleCapabilities.Features` | 自增列 IDENTITY vs 序列+触发器 | +| Oracle | ~~DDL 写死 `JSON` / 写死 `JSON(:p)`~~ **已接能力位** | `OracleTableHandler.UseJsonNativeType` / `CustomOracleAdapter.UseJsonNativeType` ← `OracleFeatures.JsonNativeType` | 列类型 `JSON` vs `CLOB`;路径更新值 `JSON(:p)` vs `:p FORMAT JSON` | +| SQLite | ~~`JSONBackend.Binary` 无条件生效~~ **已接能力位** | `SqliteCapabilities.UseBinaryJson()` ← `SqliteFeatures.Jsonb`(3.45+) | 老版本自动降级 `jsonb_*` → `json_*`;`OpenBeforeRead => false`(**探测不建库文件,实测**) | +| PG / KingbaseES / Dameng | **不接入探测** | — | 实测没有按版本二选一的分支 ⇒ 探测结果无处可用,接入只会白搭一次连库开销 | + +- **未知版本的基线策略是方言私有的,可以相反**:Oracle / MySQL 取**保守**(未知 → `None`:序列+触发器、CLOB、旧式 `WITH ROLLUP`),因为新写法在旧库直接失败;SqlServer / **SQLite** 取**乐观**(未知 → `Full`),因为它们的旧写法在新库仍可跑,且乐观能保证 `DetectVersion=false` 的 ToSql 场景**生成出与引入探测前一致的 SQL**(SQLite 的 `JSONBackend.Binary` 正是靠这条不变)。别把某一方的策略当通用规则。 +- **能力位只登记"有多套写法"的能力**(用户口径:只在涉及不同实现的地方才按版本判断)。SqlServer 只留 `OffsetFetch`(`OFFSET/FETCH` vs `ROW_NUMBER` 包裹)与 `TrimFunction`(`TRIM()` vs `LTRIM(RTRIM())`)。像 `JSON_VALUE`/`JSON_MODIFY`(仅 2016+)、`STRING_AGG`(仅 2017+)只有一种实现 → **不判版本**,低版本交给数据库报错("自己抛 NotSupported 和数据库报错差别不大")。 +- **SqlServer 分页的硬约束**:`OFFSET ... FETCH NEXT` 前面必须有 `ORDER BY`,否则报 `Incorrect syntax near 'OFFSET'` / `Invalid usage of the option NEXT`。`CustomSqlServerAdapter.Paging` 在 `builder.OrderBy.Count == 0` 时按主键补一个 `ORDER BY`;`SelectBuilder` 正是 `OrderBy.Count > 0` 才写 ORDER BY,故该信号精确。**注意**:这条路径以前从未被覆盖——老代码 `Paging` 只判 `== Over2012`,而测试用的是 `V1`/`Over2017`,全部走 ROW_NUMBER 分支,所以接上探测后(探测到 16.0)才第一次真正执行 `OFFSET/FETCH`。 +- **探测是可选特性**:`TableOptions.SpecificVersion` 有值 → 不探测(`ForVersion`,`Source=Explicit`);`TableOptions.DetectVersion = false`(基类,默认 true)→ 不探测;连接串为空 → 不探测。三条出口 + 探测失败,各方言按自己的基线(SqlServer=完整功能)。典型用途:ToSql 纯 SQL 生成场景(不连库)。 +- 版本在**构造期烘焙**:`SqlServerProvider` 构造里先建 `Capabilities`,再 `SqlServerTableHandler` / `SqlServerMethodResolver(Capabilities)` / `CustomSqlServerAdapter(Capabilities, …)`(MySQL/Oracle 同序:必须先取 `option.NewFactory ?? XxxFactory.Instance`,因为原来 `DbProviderFactory` 属性是在最后一行才赋值的)。 +- **进程内版本切换**:SqlServer 的 `SqlServerMethodResolver` 现在有无参构造(= `Baseline` = 完整功能),公开构造改收 `SqlServerCapabilities`。 +- **能力档案基类只有一层**(`src/LightORM/Implements/DbCapabilities.cs`):`DbCapabilities`,给 `Baseline` / `ForVersion` / `Start` / `ServerVersion` / `Version` / `Source` / `IsResolved` / `Override` / `Features`;方言给 `ProbeTarget`(抽象)+ `MapFeatures`(抽象),`PrepareProbeConnectString` / `OpenBeforeRead` 是**虚成员带默认值**(默认不改写连接串、默认先 Open)。 + - `ProbeTarget` / `PrepareProbeConnectString` / `MapFeatures` **都是实例成员**(见下条原因)。 + - **不要为"无能力位的方言"拆一个 1 参基类**:那层会变成零实现的死抽象。用户口径是"探测的唯一目的是喂能力位,没有能力位就不要探测"。若将来真出现"要探测但暂时没能力位"的方言,再补一个框架自带的空枚举 + `MapFeatures` 默认实现。 + - **net462 / netstandard2.0 不支持接口静态抽象成员**(`static abstract` 需 .NET 7+ 运行时),基类也没有抽象静态方法 ⇒ 静态工厂要拿方言信息,只能 `new TDatabase()`(`new()` 约束)借一个**空实例**当元数据载体,读出探测键/连接串改写/`OpenBeforeRead`,再把 `DbVersionProbe` 写回该实例返回(CRTP 下基类通过类型参数访问 `protected` 成员是合法的)。 + - `Probe` 是 `protected { get; set; }`(原为 `public required`);`OpenBeforeRead` 是 `protected virtual`,**SQLite 覆盖为 false**——它未 Open 即可读 `ServerVersion`,而 Open 会在文件不存在时建出空库文件(纯 SQL 生成场景绝不能碰)。 +- **实测服务端版本串**(写临时 MSTest 打印 `conn.ServerVersion`,跑完删除):Sqlite `3.46.1` / PG `16.4 (Debian 16.4-1.pgdg120+1)` / **KingbaseES `12.1`(是 PG 兼容版本号,不是 `V009R001C001B0025`)** / Dameng `8.1.4.6`。 + - 备用(PG/KES/Dameng 目前**不**接入探测,故未使用,需要时直接可用):`NpgsqlConnectionStringBuilder.Timeout`、`KdbndpConnectionStringBuilder.Timeout`、`DmConnectionStringBuilder.ConnectionTimeout` 三者都存在且已编译验证;SQLite 无需改写连接串。 +- **达梦 JSONB 实测(DM 8.1.4.6)**:`CREATE TABLE t (C1 JSONB)` 能建成功,但 `JSONB_VALUE` / `JSONB_QUERY` **函数不存在**(`JSON_VALUE` 正常)。⇒ `JSONBackend.Binary` 在达梦不可用,但**与版本无关**,属"只有一种写法",**不登记能力位**,保留默认 `Text`。 +- **`Resolve` 表达式缓存是静态且方言无关**:key = `(SqlAction, Hash, NestedLevel)`(`Utils/ExpressionResolver.cs`),无方言维度 → 同进程内不同方言/不同版本的同类 provider 会串味(**既存缺陷,非版本探测引入**)。 + - 正确键模型 = `(SqlAction, 标识符引用身份, Hash, Depth)`;身份至少含 `Emphasis` + 生效引用开关(`QuoteIdentifiers ?? UseIdentifierQuote`)。**只放 `Emphasis` 不充分**(Oracle 与 PG 都是 `""`;且同方言逐语句 `.QuoteIdentifiers()/.NoQuoteIdentifiers()` 就翻转)。 + - **参数前缀不是维度**:解析期不读 `database.Prefix`,它由 `SqlBuilder.HandleSqlParameters` 的 `AttachPrefix` 事后补。 + - **状态(09-17):该改动已整体回滚**(用户决定先不处理),`ExpressionResolver.cs` 与 HEAD 零差异;详细反例与证据留档在 `memory/2026-09-17.md`。重新捡起时**先查**"多方言同进程时 PG 输出整段是 Oracle 的"那条异常(疑点:投影段 `ResolveContext.Database` 不是当次 adapter / `TryGet` 探不到)。 +- 版本探测线**已落地**(保留中):`Models/DbServerVersion.cs`(`CapabilitySource` + 版本模型)、`Implements/DbVersionProbe.cs`(构造期后台探测:单飞 / 限时 / 永不 fault / 后台自愈,**零方言词汇**)、`Providers.Oracle/OracleCapabilities.cs`(`[Flags] OracleFeatures` + `MapFeatures`,方言语义归 provider)。核心只做机制,不认识任何方言能力名。 +- **显式版本优先于探测**:`TableOptions.SpecificVersion`(**已在基类** `DbStruct/TableGenerateOption.cs:9`)有值时,`OracleCapabilities.Start(..., specificVersion)` 走 `ForVersion` → **不发起后台 Task、不建连**(实测 0ms / `Source=Explicit`)。 + - 坑:`DbVersionProbe.None` 原为**共享单例**而 `Override` 改实例字段 → 已改为 `=> new(null)` 每次新实例,否则显式覆盖会污染 `OracleCapabilities.Baseline`。 +- **Oracle 身份列 DDL 的两条硬约束(实测 21c,必须同时满足)**:`GENERATED ALWAYS AS IDENTITY` 必须紧跟数据类型(写在 `NOT NULL` 之后报 `ORA-00907`),且身份列不能显式写 `NULL`(报 `ORA-30670`)。见 `OracleTableHandler.Writer.BuildColumn`。 +- **连接超时由方言"改写连接串"**(核心不枚举、不猜测键名):`DbVersionProbe.Start(..., Func? prepareConnectString)` —— 核心只给策略(探测必须秒级返回),表达方式是方言私有知识。Oracle 用强类型 `new OracleConnectionStringBuilder(cs){ ConnectionTimeout = seconds }`(实测改写生效:黑洞地址 5090ms → 2001ms,构造仍 1ms 不阻塞,读 Version 恰好一次超时 2014ms → Assumed)。 + - 不用"超时键名字符串"的理由:写错只能运行期发现;且实测 SqlServer/MySql/PG/KES **都接受 `Command Timeout` 且读回值相等**(映射另一属性)⇒ 按键名试探无法区分语义,"写回读校验"也兜不住。 + - 坑:ODP.NET 的 `OracleConnectionStringBuilder` 输出会**把键名大写归一化**(`CONNECTION TIMEOUT=2`),键名本身大小写不敏感,别用原文 Contains 做断言。 + - 委托 `internal static string? PrepareProbeConnectString(cs, seconds)`:返回 null / 抛异常 → 核心沿用原连接串。 +- **Oracle JSON 能力的版本分界(实测 + 官方文档)**:原生 `JSON` 列类型 / `JSON()` 构造器 / `JSON_TRANSFORM` 均 **21c+**(19c 建 `JSON` 列报 ORA-00902;`JSON_TRANSFORM` 被回移到 19c 但**仅较新 RU**:19.3 无、19.17 有 ⇒ 版本号不可靠)。`JSON_VALUE`/`JSON_QUERY` 需 **12.1.0.2+**,且**对 CLOB 文本列同样有效**(无需 `IS JSON` 约束)。`FORMAT JSON` 12.1 起语法被接受但**18c 才真正生效**(12c 文档标注"仅为语义清晰",含该子句会不稳定地影响输出)。`CAST('...' AS JSON)` 在 21.3 XE 上报 **ORA-00600 内部错误**,别用。 + - 非原生分支用 `:p FORMAT JSON` 而非 `JSON_MERGEPATCH`:后者是**整文档合并**语义,等价不了"设置某路径"(对象会合并、数组下标无法设),会静默写错数据。 + - `SqlFn.JsonSet` 口子**不接能力位**:它的值是用户手写的 SQL 表达式(PG 侧要写 `'"NewName"'`),套 `FORMAT JSON` 会把 `'test'` 变成非法 JSON 文本。 +- **`InternalCreateTableAsync` 吞异常并 return false**(`ExpressionCoreSqlContextMethodImpl.cs:211`)→ DDL 失败不抛,只在后续操作以 `ORA-00942 表或视图不存在` 暴露。排查 ORA-00942 先怀疑建表静默失败。 +- `ExpressionSqlOptions.SetDatabase` 只保留每个 `DbBaseType.Name` 的**第一个** adapter(`customDatabases`),`ResolveContext.Create(DbBaseType)` 走它;且 `databaseProviders/customDatabases/defaultDbKey` **全是 static 全局**,同名 key 走 `TryAdd` = **先注册者胜、后来者静默丢弃**(多方言 A/B 必须用具名 key + `SetDefault` 切换)。 +- `Builder/AdapterCapability.TryGet` 已存在:穿透 `ScopedDatabaseAdapter` 探测能力接口 → 新增能力不必改 `IDatabaseAdapter`(不破坏第三方实现)。 + +## 反向读表结构(`GetTablesSql` / `GetTableStructSql` / `ParseDataType`) +- 现状(2026-09-18):**七个方言全部实现**,不再有 `NotImplementedException`。 +- 达梦实现(`src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs`)——**坑最多,动手前先看这几条**: + - 列表:`SELECT TABLE_NAME AS TableName FROM USER_TABLES ORDER BY TABLE_NAME`。 + - 结构主表 `USER_TAB_COLUMNS`(Oracle 风格),另需三张辅助对象(全部 `LEFT JOIN`,挂不上只会让该列退化为 `NO`/空串): + `USER_COL_COMMENTS`(注释)、`USER_CONSTRAINTS`+`USER_CONS_COLUMNS`(主键)、 + **`SYSCOLUMNS`**(经 `SYSOBJECTS.NAME=tc.TABLE_NAME AND TYPE$='SCHOBJ' AND SUBTYPE$='UTAB'` 定位)。 + - **`USER_TAB_COLUMNS` 没有 `IDENTITY_COLUMN` 列**(实测报"无效的列名"),IDENTITY 列的 `DATA_DEFAULT` 也是空的 ⇒ 自增只能从 `SYSCOLUMNS.INFO2` 的 bit0 判:`(NVL(s.INFO2,0) & 1) = 1`。实测 IDENTITY 列 `INFO2=1`、普通列 `0`。 + - **`USER_TAB_COLUMNS.DATA_LENGTH` 对 `NVARCHAR2` 是字节数**:`NVARCHAR2(64)` 给 128,且 `CHAR_LENGTH=0`。 + **`SYSCOLUMNS.LENGTH$` 才是字符数**(给 64)⇒ Length 一律取 `s.LENGTH$`。这条最容易踩。 + - **JSON / JSONB 物理存成 `BLOB`**(`DATA_TYPE='BLOB'`),与真 BLOB 无法靠类型名区分。 + 判别特征:`SYSCOLUMNS.SCALE = 16384`(达梦给 JSON 的 BLOB 打的内部子类型标记,普通 BLOB 为 0)。 + SQL 里改写成 `CASE WHEN DATA_TYPE='BLOB' AND s.SCALE=16384 THEN 'JSON' ELSE DATA_TYPE END`。 + 另有官方视图 `USER_JSON_COLUMNS(TABLE_NAME,COLUMN_NAME,FORMAT,DATA_TYPE)` 可用,但它是随 JSON 特性附带引入的, + 用 `SYSCOLUMNS` 少一层"视图是否存在"依赖(失败模式也更温和:读成 byte[] 而非整条 SQL 报错)。 + - **`DATA_SCALE` 不是纯小数位**:非数值类型也占它 —— JSON/JSONB=16384、`NVARCHAR2`/`NVARCHAR`=7、`NCHAR`=8、`TIMESTAMP`=6。 + 所以数值分支要 `WHEN s.TYPE$ IN ('DECIMAL','NUMERIC','NUMBER','DEC') AND s.LENGTH$ > 0` 双重限定。 + - Length 表达式:LOB 类(TEXT/CLOB/BLOB/IMAGE/LONGVARCHAR/LONGVARBINARY)给 `''`;数值类给 `"精度,标度"`(标度 0 时只给精度);其余 `s.LENGTH$ > 0` 才给 `TO_CHAR(s.LENGTH$)`,否则 `''`。 + - `ParseDataType`:`DATA_TYPE` 是**不带括号的纯类型名**(`VARCHAR2`/`DECIMAL`/`CHAR`),所以定点细分只能靠 `column.Length`(`"18,2"` / `"9"`)。 + `NumericType` 分档:带逗号 → decimal;无精度信息 → **decimal**(达梦裸 `NUMBER` 是浮点语义,给 int 遇小数会炸)。 + - 类型事实(实测 DM 8.1.4.6):**`BOOLEAN` 和 `UUID` 不能建列**("无效的数据类型" / "非法的基类名"); + `NCLOB`/`XMLTYPE` 被归一化成 `TEXT`;`BINARY_DOUBLE`→`DOUBLE`; + **`FLOAT` 是 8 字节双精度、`REAL` 才是 4 字节单精度**(所以 `ParseDataType` 里 FLOAT→double、REAL→float,与 writer 的 `Single→FLOAT` 刻意不对称)。 + - 与 writer 不对称是刻意的:`bool` 写 `CHAR(1)`、`Guid` 写 `CHAR(36)`,读回都只能给 `string`(真 `CHAR(1)` 多存 `'Y'`/`'N'`,猜 bool 会反序列化失败)。口径同 SQLite:**不做 writer 私有约定的逆向猜测**。 + - 达梦支持 `DROP TABLE IF EXISTS`(探针用得上)。表名精确匹配(`WHERE tc.TABLE_NAME = '{t}'`),不做 `UPPER()` 模糊,避免大小写不同的同名表混在一起。 +- 探针方法(本次全程这么干的,以后摸新方言照此办理):写临时 MSTest 类 + `DmConnection` 直连, + 先**逐类型 `CREATE TABLE ("C1" )`** 打出支持/不支持,再建一张"全类型表"用 `SELECT * FROM USER_TAB_COLUMNS` / + `SYSCOLUMNS` 打印**每个列的元数据**(DATA_TYPE/DATA_LENGTH/DATA_PRECISION/DATA_SCALE/CHAR_LENGTH/LENGTH$/SCALE/INFO2), + 最后把**最终 SQL 原样预演一遍**。比反复改 C# 跑测试快一个数量级。 +- SQLite 实现(`src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs`): + - 列表:`sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite\_%' ESCAPE '\'`(排除引擎内部表)。 + - 结构:用**表值函数 `pragma_table_info('t')`**,**不能**用 `PRAGMA table_info(t)` 命令 —— 命令不能出现在 SELECT/子查询里,而"是不是 rowid 别名"要数同表主键列个数。 + - `IsIdentity`:`pk>0 AND upper(trim(type))='INTEGER' AND (SELECT COUNT(*) ... pk>0)=1`。 + - `Nullable`:`notnull=1 OR pk>0` → `'NO'`;`Comments` 恒 `''`(SQLite 无列注释);`Length` 从声明类型括号里切。 + - 表名要塞进字符串字面量 ⇒ 必须 `Replace("'", "''")`(带单引号的表名否则把查询拆坏)。 + - `ParseDataType`:先剥 `(len)` 再 `ToUpperInvariant()` 精确匹配;未命中按 **SQLite 官方亲和性顺序**兜底(INT → CHAR/CLOB/TEXT → BLOB → REAL/FLOA/DOUB),都不中 → `object?` 且 `return false`(NUMERIC 兜底桶不猜)。**顺序不可改**:`FLOATING POINT` 里 `POINT` 含 `INT` ⇒ 引擎判定它是 INTEGER 亲和性。 + - net462 无 `System.Range`/`System.Index` ⇒ 用 `Substring(0, paren)`,不能写 `declared[..paren]`。 + - 写/读**不一一对应**:写出去 byte/sbyte/short/ushort/int/uint/long/ulong/bool 全落 `INTEGER`,float/double/decimal 全落 `REAL`,读回只能取 `int` / `double`;要精确类型得显式声明(`BIGINT`、`DECIMAL(18,2)`)。 +- 验证方式(**曾用的测试文件已被用户主动删除、未入库**):`test/LightORMTest.Sqlite/SchemaReadTest.cs`(5 用例,5/5 通过) + 与 `test/LightORMTest.Dameng/SchemaReadTest.cs`(4 用例,4/4 通过)曾用于验证这两处实现,提交前由用户移除 ⇒ + **不要把"反向读表有回归测试"当既成事实**。将来补这类用例时要表自建自删,且不要继承 InitData 重建 + (达梦单次 init ≈5s,别挂到共享 ExecutionTest 下)。 + +## JSON 列与方言约定 +架构:序列化下沉到 `IDatabaseParameterBinder.BindParameter`;`DbParameterValue` 携带原始 CLR 值;`CustomDatabaseAdapter` 给默认 json 绑定。`src/LightORM/Utils/JsonParameterHelper.cs`:`Serialize` + `IsCompositeJsonValue`(标量白名单:string/char/数值/Guid/DateTime/TimeSpan/byte[]/Uri/Version/object)+ `IsCompositeJsonLeaf(JsonColumnContext)`。 +**缓存约束**:SQL 侧"形状分支"只能由表达式结构(成员类型)决定,不能用运行时值。 + +| 方言 | 路径更新值参数 | 读末级标量 / 复合 | +|---|---|---| +| PG / KingbaseES | `@p::JSONB` | `(col->>'p')::T` / 同左(数组 `col->N`) | +| SQLite | `JSON(@p)` | `json_extract` / 同左 | +| SqlServer | 复合 `JSON_QUERY(@p)`;标量传原生值 | `JSON_VALUE` / `JSON_QUERY`(已修,未实测) | +| MySQL | `CAST(?p AS JSON)`(5.7.44 实测通过) | `col->>'$.p'` / 同左 | +| Dameng | `CAST(:p AS JSON)`(实测一律正确) | `JSON_VALUE`(Binary 起 `JSONB_VALUE`)/ **未验证** | +| Oracle | 21c+ `JSON(:p)`;≤19c `:p FORMAT JSON`(均在 JSON_TRANSFORM 内) | `JSON_VALUE` / `JSON_QUERY`(21c XE 通过) | + +- **整列更新一律 `col = @p`**(无路径成员时)。MySQL `JSON_SET` 首参 NULL → 整体 NULL(静默丢值);KingbaseES `JSONB_SET` 空路径不能替换整文档。 +- 例外:`SqlFn.JsonSet(path,value)` 走 `XxxMethodResolver`,值参数**不序列化**;PG 侧用户自传 JSON 文本(`"\"NewName\""`)。MySQL 侧传原始 CLR 值。 +- MySQL 受影响行数:`ON DUPLICATE KEY UPDATE` 插入 1 / 更新 2 → 断言按 DbType 分支。 +- `DbBaseType` 是 record(按 Name 相等),Kingbase 的 Name 是 `"KingbaseES"` → 写 `DbType.Name is "PostgreSQL" or "KingbaseES"`。 +- 达梦列类型默认 `JSON`(>320000 走 CLOB);`JSONBackend.Binary` 在本机 DM8 不可用,用默认 `Text`。 +- 定位 json 问题先写**方言语义探针**(Python sqlite3 / sqlcmd / DmCommand)验证函数行为,比反复改 C# 跑测试快。 + +## 测试基础设施 +- 容器常驻:`dm8` 5236 / `kes` 54321 / `oracle21xe` 1521(`localhost:1521/XE`,lightorm_test) / `mysql` 3306(**本机 MySQL 5.7.44**:无 CTE/窗口函数,CUBE 抛 NotSupported,MySql 全量 144/155,失败 11 个全部由此而来)/ `pgsql` 5432 / `mssql` 1433。 +- 用例数:Dameng 270 / Oracle 194 / Sqlite 168 / KingbaseES 100。 +- **Sqlite 全量别想一次跑完**:单用例含 20s 级底噪,全量 >15min 会被工具超时打断(要用 `--filter` 收窄,如 `~Json`)。收窄跑时看到 `Group_Cube_Test` 因 `no such function: CUBE` 失败——SQLite 本就不支持 `CUBE`(MySQL 侧早就改成"交给数据库报错",这个用例在 Sqlite 上注定失败),与版本能力位无关。 +- 每个用例前 `ExecutionTest.InitData.cs` 的 `[TestInitialize]` 重建整个 schema(10 表 DROP+CREATE + 8 表清空重插)→ 每个用例都有几秒底噪,MSTest 耗时含它。 +- 达梦慢的真原因:① DDL 单条约 25ms/条且每条自带提交,单次 init ≈4.8s(Kingbase 同项 0.57s);② `DamengTableHandler.Writer` 把 CREATE/COMMENT/INDEX 各 yield 一次(10 表 = 131 条语句 = 131 次往返),PG/Kingbase 每表 yield 一次。**批量化已实测不可行**(`;` 多语句被拒;匿名块慢 7 倍)→ 只能减少 DDL 条数/次数。 +- 重复测试类:Dameng / PostgreSQL / SqlServer 项目里 `ResultTest/ExecutionTest.cs` 与 `SelectResult.cs` 都继承共享 `ExecutionTest`(100 用例) → 共享套件跑两遍。 diff --git a/DatabaseUtils.Avalonia/ViewModels/MainViewModel.cs b/DatabaseUtils.Avalonia/ViewModels/MainViewModel.cs index 85890452..a5253a22 100644 --- a/DatabaseUtils.Avalonia/ViewModels/MainViewModel.cs +++ b/DatabaseUtils.Avalonia/ViewModels/MainViewModel.cs @@ -33,7 +33,7 @@ public MainViewModel(IExpressionContext context) supportedDb.Add(DbBaseType.Oracle.Name, str => OracleProvider.Create(o => o.MasterConnectionString = str)); supportedDb.Add(DbBaseType.PostgreSQL.Name, str => PostgreSQLProvider.Create(o => o.MasterConnectionString = str)); supportedDb.Add(DbBaseType.MySql.Name, str => MySqlProvider.Create(o => o.MasterConnectionString = str)); - supportedDb.Add(DbBaseType.SqlServer.Name, str => SqlServerProvider.Create(SqlServerVersion.V1, o => o.MasterConnectionString = str)); + supportedDb.Add(DbBaseType.SqlServer.Name, str => SqlServerProvider.Create(o => o.MasterConnectionString = str)); SupportedDbNames = [.. supportedDb.Keys]; // 从配置恢复上次的状态(经属性赋值,保持与界面绑定一致) diff --git a/DatabaseUtils/WpfApp.razor.cs b/DatabaseUtils/WpfApp.razor.cs index f7c1fd60..05b9f6de 100644 --- a/DatabaseUtils/WpfApp.razor.cs +++ b/DatabaseUtils/WpfApp.razor.cs @@ -30,7 +30,7 @@ protected override void OnInitialized() supportedDb.Add(DbBaseType.Oracle.Name, str => LightORM.Providers.Oracle.OracleProvider.Create(o => o.MasterConnectionString = str)); supportedDb.Add(DbBaseType.PostgreSQL.Name, str => LightORM.Providers.PostgreSQL.PostgreSQLProvider.Create(o => o.MasterConnectionString = str)); supportedDb.Add(DbBaseType.MySql.Name, str => LightORM.Providers.MySql.MySqlProvider.Create(o => o.MasterConnectionString = str)); - supportedDb.Add(DbBaseType.SqlServer.Name, str => LightORM.Providers.SqlServer.SqlServerProvider.Create(SqlServerVersion.V1, o => o.MasterConnectionString = str)); + supportedDb.Add(DbBaseType.SqlServer.Name, str => LightORM.Providers.SqlServer.SqlServerProvider.Create(o => o.MasterConnectionString = str)); } async Task Connect() diff --git a/LightORM.slnx b/LightORM.slnx index 6b33af27..57fec1f1 100644 --- a/LightORM.slnx +++ b/LightORM.slnx @@ -40,7 +40,6 @@ - diff --git a/README.md b/README.md index a6a7ba56..429883c4 100644 --- a/README.md +++ b/README.md @@ -343,10 +343,16 @@ public virtual void Exits(IExpressionResolver resolver, MethodCallExpression met - `ToString()` → `CONVERT(VARCHAR(MAX), ...)`,且**把 .NET 日期格式字符串映射成 SQL Server 的 style code**(`"yyyy-MM-dd"` → 23,`"yyyyMMdd"` → 112 等),这是非常贴合实际业务痛点的细节。 - `Contains` 区分 `string.Contains`(→ `LIKE '%'+x+'%'`)和集合 `Contains`(→ `IN (...)`)。 -- `Join` 聚合根据 `SqlServerVersion` 决定用 `STRING_AGG`(2017+)还是抛异常。 +- `Join` 聚合 → `STRING_AGG`(2017+ 才有;低版本不预判,直接交给数据库报错——只有一种写法,判版本只是多一条无意义的失败分支)。 - `JsonQuery` → `JSON_VALUE`,`JsonSet` → `JSON_MODIFY`。 -**版本感知**:`SqlServerMethodResolver` 构造函数接收 `SqlServerVersion` 枚举,同一 SQL 片段在不同 SQL Server 版本下生成不同函数——这是 `TRIM`(2017+ 原生 vs 兼容写法)等函数能正确工作的原因。 +**版本感知**:`SqlServerMethodResolver` / `CustomSqlServerAdapter` 接收 `SqlServerCapabilities`——由构造期后台探测的服务端版本(或显式 `SpecificVersion`)翻译成能力位,同一 SQL 片段在不同 SQL Server 版本下生成不同函数。当前只登记**"存在两套写法"**的能力:`OffsetFetch`(2012+ 的 `OFFSET/FETCH` vs `ROW_NUMBER` 包裹)与 `TrimFunction`(2017+ 原生 `TRIM` vs `LTRIM(RTRIM())`);只有一种写法的能力(如 `JSON_VALUE`、`STRING_AGG`)不判版本,交给数据库报错即可。 +探测是可选特性:`SpecificVersion` 已指定或 `DetectVersion = false`(典型的 ToSql 纯生成场景)时不建连,**探测失败或未探测也一律按完整功能生成**(SqlServer 的能力位都是"新写法在老版本报错、旧写法在新版本仍可跑",故乐观基线更合理)。 + +**能力档案的公共骨架**:`DbCapabilities`(`src/LightORM/Implements/DbCapabilities.cs`)承载探测的全部机制——单飞、后台重试自愈、连接串超时改写、`Baseline`/`ForVersion`/`Start`;方言只实现 `ProbeTarget` 与 `MapFeatures(Version?) → TFeatures`,`PrepareProbeConnectString` / `OpenBeforeRead` 有默认值可按需覆盖。 +> net462 / netstandard2.0 不支持接口静态抽象成员,故方言元数据用**实例成员**表达:静态工厂先 `new TDatabase()` 借一个空实例读出探测键与连接串改写委托(CRTP + `new()` 约束),空实例只是元数据载体。 + +**接入探测的只有四个方言**:`SqlServerCapabilities` / `MySqlCapabilities` / `OracleCapabilities` / `SqliteCapabilities`——它们各自有"两套写法"的能力位,探测结果有地方用。PostgreSQL / KingbaseES / Dameng **不接入**:实测它们的 SQL 生成本就没有按版本二选一的分支,探测结果无处可用,只会白搭一次连库开销(`SpecificVersion` / `DetectVersion` 在这三个方言上也没有语义)。 ### SelectBuilder:SQL 的结构组装器 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" index 520730d6..30c5231f 100644 --- "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" @@ -544,10 +544,14 @@ AOT 下的行为差异: | `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` | | | | | +| 分组聚合 | `STRING_AGG`(2017+ 才有;不按版本预判,低版本交给数据库报错) | `GROUP_CONCAT` | | | | | | 批量插入 | `SqlBulkCopy` | 不支持(多行 VALUES) | | | | | -**版本感知**:`SqlServerMethodResolver` 构造接收 `SqlServerVersion` 枚举,同一 SQL 片段在不同版本生成不同函数(如 `TRIM` 在 2017+ 用原生)。 +**版本感知**:`SqlServerMethodResolver` / `CustomSqlServerAdapter` 接收 `SqlServerCapabilities`——构造期后台探测的服务端版本(或 `SpecificVersion` 显式指定)翻译成能力位,同一 SQL 片段在不同版本生成不同函数(如 `TRIM` 在 2017+ 用原生、分页在 2012+ 用 `OFFSET/FETCH`)。 +**只登记"存在两套写法"的能力**(SqlServer:`OffsetFetch` / `TrimFunction`;MySQL:`GroupByRollup`;Oracle:`IdentityColumn` / `JsonNativeType`;SQLite:`Jsonb`),只有一种写法的能力不判版本——硬判只会多一条走不到的失败分支,交给数据库报错即可。探测可用 `SpecificVersion` 或 `DetectVersion = false` 关闭;**未探测 / 探测失败按该方言的基线策略生成**(SqlServer / SQLite 乐观取完整功能,MySQL / Oracle 保守退旧写法)。 + +**能力档案骨架**:`DbCapabilities` 承载全部探测机制(单飞、后台重试自愈、连接串超时改写、`Baseline`/`ForVersion`/`Start`),方言只给 `ProbeTarget` + `MapFeatures(Version?) → TFeatures`(`PrepareProbeConnectString` / `OpenBeforeRead` 有默认值)。net462 不支持接口静态抽象成员,故用 CRTP + `new TDatabase()` 空实例传递方言元数据。 +**只有存在"两套写法"的方言才接入探测**(SqlServer / MySQL / Oracle / SQLite)——探测的唯一目的是喂能力位;PostgreSQL / KingbaseES / Dameng 实测没有版本相关分支,不接入,避免白搭一次连库开销。 ### 6.3 新增一个数据库 = 实现 5 个类 diff --git a/src/LightORM/DbStruct/TableGenerateOption.cs b/src/LightORM/DbStruct/TableGenerateOption.cs index 2015762b..68dbcc99 100644 --- a/src/LightORM/DbStruct/TableGenerateOption.cs +++ b/src/LightORM/DbStruct/TableGenerateOption.cs @@ -6,6 +6,20 @@ public TableOptions() { } + /// + /// 显式指定数据库版本。一旦指定,则不发起版本探测;同时它优先于探测结果。 + /// + public Version? SpecificVersion { get; set; } + + /// + /// 是否允许在构造期后台探测数据库版本,默认开启。 + /// + /// 支持版本差异的方言会把探测结果翻译成自己的能力位;关掉探测(如 ToSql 纯 SQL 生成场景, + /// 不需要也不应该建连)时按完整功能处理。探测失败同样落到完整功能。 + /// + /// + public bool DetectVersion { get; set; } = true; + public bool NotCreateIfExists { get; set; } public bool UseUnicodeString { get; set; } = true; public bool SupportComment { get; set; } = true; diff --git a/src/LightORM/ExceptionPolyfills.cs b/src/LightORM/ExceptionPolyfills.cs index b199e04e..5335a1b1 100644 --- a/src/LightORM/ExceptionPolyfills.cs +++ b/src/LightORM/ExceptionPolyfills.cs @@ -42,6 +42,31 @@ internal static void ThrowObjectDisposedException(object? instance) namespace System.Runtime.CompilerServices { + [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)] + internal sealed class CompilerFeatureRequiredAttribute : Attribute + { + public CompilerFeatureRequiredAttribute(string featureName) + { + FeatureName = featureName; + } + + public string FeatureName { get; } + public bool IsOptional { get; init; } + + public const string RefStructs = nameof(RefStructs); + public const string RequiredMembers = nameof(RequiredMembers); + } + + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)] + internal sealed class RequiredMemberAttribute : Attribute + { + } + + [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)] + internal sealed class SetsRequiredMembersAttribute : Attribute + { + } + internal sealed class NotNullAttribute : Attribute { } diff --git a/src/LightORM/Implements/DbCapabilities.cs b/src/LightORM/Implements/DbCapabilities.cs new file mode 100644 index 00000000..0cfe2e86 --- /dev/null +++ b/src/LightORM/Implements/DbCapabilities.cs @@ -0,0 +1,127 @@ +using System.Data.Common; + +namespace LightORM.Implements; + +/// +/// 数据库能力档案的公共骨架:探测机制全部在这里,方言只提供差异。 +/// +/// 方言需要实现两样: 与 ; +/// / 有默认值可按需覆盖; +/// / / 以及所有读取成员都由基类提供。 +/// +/// +/// 只有"同一 SQL 片段存在两套写法、需要按版本二选一"的方言才需要有这个类——探测的唯一目的就是喂 +/// 。没有任何版本相关分支的方言不要接入:探测结果无处可用 +/// +/// net462 / netstandard2.0 的运行时不支持接口中的静态抽象成员(static abstract 需要 .NET 7+ 运行时,net462 上不可用) +/// +public abstract class DbCapabilities + where TDatabase : DbCapabilities, new() +{ + /// + /// 探测状态。只由基类的静态工厂写入;读取请走 等公开成员。 + /// + protected DbVersionProbe Probe { get; set; } = DbVersionProbe.None; + + /// + /// 探测的单飞键,用 (同一键 + 同一连接串全进程只探测一次)。 + /// + protected abstract string ProbeTarget { get; } + + /// + /// 把探测用的连接串改写成"带秒级连接超时"的版本;返回 null 表示不改写。 + /// + /// 核心只给策略(探测必须秒级返回),怎么表达超时是方言的私有知识:SqlServer 用 + /// SqlConnectionStringBuilder.ConnectTimeout、Oracle 用 ConnectionTimeout、MySQL 用 ConnectionTimeout(uint)…… + /// 按"超时键名"字符串试探区分不了语义(多个驱动同时接受 Command Timeout 且读回值相等),故交给方言。 + /// + /// 默认不改写;返回 null 或抛异常时,核心沿用原连接串让探测自己去失败。 + /// + protected virtual string? PrepareProbeConnectString(string connectionString, int timeoutSeconds) => null; + + /// + /// 读取 前是否必须先 Open。 + /// 除 SQLite 外所有驱动在关闭连接上读该属性都会抛异常,故默认 true; + /// SQLite 覆盖为 false——它未 Open 即可读,且对其 Open 会在文件不存在时建出一个空库文件。 + /// + protected virtual bool OpenBeforeRead => true; + + /// + /// 版本 → 能力位。版本不可用(未探测 / 探测失败 / 未启用探测)时的基线策略由方言自己定: + /// 可以保守(退到全版本可用的旧写法),也可以乐观(按完整功能生成),取决于该方言的能力位是否 + /// "新写法在旧库直接失败"。直接比版本分量,不要构造 Version 实例做比较。 + /// + public abstract TDatabaseFeatures MapFeatures(Version? version); + + /// 服务端版本,含原始串与来源(Explicit / Probed / Assumed)。 + public DbServerVersion ServerVersion => Probe.Value; + + public Version? Version => ServerVersion.Parsed; + + public CapabilitySource Source => ServerVersion.Source; + + /// 探测是否已就绪(诊断用,不做等待)。 + public bool IsResolved => Probe.IsResolved; + + /// 能力位。由版本推导,故必须与 SQL 生成期的读取保持一致。 + public TDatabaseFeatures Features => MapFeatures(Version); + + /// 显式指定版本,优先级高于探测结果。 + public void Override(Version? version) => Probe.Override(version); + + /// 不探测(未启用探测 / 纯 SQL 生成 / 静态实例),版本视为未知。 + public static TDatabase Baseline { get; } = ForProbe(new TDatabase(), DbVersionProbe.None); + + /// 使用显式指定的版本,不发起后台探测。 + public static TDatabase ForVersion(Version version) => ForProbe(new TDatabase(), version); + + /// + /// 构造期发起后台探测。三条不探测的出口,结果都落到 : + /// + /// 已给定——用户既然指定了版本,就没有连库的必要; + /// 为 false——用户主动关闭探测(典型的 ToSql 纯生成场景); + /// 为空——没有可探测的目标。 + /// + /// 探测本身失败(连不上 / 未就绪)与上述出口同结果:版本视为未知,能力位落到方言的基线策略。 + /// + public static TDatabase Start(DbProviderFactory factory, + string connectionString, + Version? specificVersion = null, + bool detectVersion = true) + { + if (specificVersion is not null) + { + return ForVersion(specificVersion); + } + + if (!detectVersion || string.IsNullOrWhiteSpace(connectionString)) + { + return Baseline; + } + + // 借一个空实例读出方言元数据(探测键 / 连接串改写 / 是否需先 Open),探测结果也写回它。 + var metadata = new TDatabase(); + var probe = DbVersionProbe.Start(metadata.ProbeTarget, + factory, + connectionString, + metadata.PrepareProbeConnectString, + openBeforeRead: metadata.OpenBeforeRead); + + return ForProbe(metadata, probe); + } + + /// 把探测状态写进实例( 为 None 即"不探测")。 + private static TDatabase ForProbe(TDatabase capabilities, DbVersionProbe probe) + { + capabilities.Probe = probe; + return capabilities; + } + + /// 在空实例上写显式版本(等同 ,供静态工厂使用)。 + private static TDatabase ForProbe(TDatabase capabilities, Version version) + { + capabilities.Probe = DbVersionProbe.None; + capabilities.Override(version); + return capabilities; + } +} diff --git a/src/LightORM/Implements/DbVersionProbe.cs b/src/LightORM/Implements/DbVersionProbe.cs new file mode 100644 index 00000000..c4bbbcd5 --- /dev/null +++ b/src/LightORM/Implements/DbVersionProbe.cs @@ -0,0 +1,275 @@ +using System.Collections.Concurrent; +using System.Data.Common; +using System.Text.RegularExpressions; +using System.Threading; +using LightORM.Models; + +namespace LightORM.Implements; + +/// +/// 数据库版本探测 +/// +/// provider 在构造期调用 发起一次后台探测,此后任意位置(含 SQL 构建期) +/// 读 即可拿到结果;尚未完成则等待其完成。 +/// +/// +public sealed class DbVersionProbe +{ + private const int DefaultTimeoutSeconds = 2; + private const int DefaultAttempts = 3; + private const int RetryBackoffMs = 1000; + + /// + /// (目标, 连接串) → 探测状态。单飞:同目标的多个 provider 实例共享同一次探测, + /// 也共享后台重试的自愈结果。条目不回收——数量由不同连接串个数决定,正常应用是个位数。 + /// + private static readonly ConcurrentDictionary> probes = + new(StringComparer.Ordinal); + + /// + /// 只取版本串的前导数字段:PG 会返回 "16.4 (Debian 16.4-1.pgdg120+1)" 这类带后缀的串。 + /// 必须最多四段—— 只接受 2~4 段,而 Oracle 的 ServerVersion 是 + /// "21.3.0.0.0"(五段),多截一段会导致 TryParse 失败并静默退化成基线。 + /// + private static readonly Regex leadingVersion = new(@"^\s*(\d+(?:\.\d+){0,3})", RegexOptions.Compiled); + + private readonly ProbeState? state; + private volatile Version? overridden; + private volatile bool hasOverride; + + private DbVersionProbe(ProbeState? state) => this.state = state; + + /// + /// 不探测,恒返回版本未知(无连接串的静态实例、纯 SQL 生成场景)。 + /// + public static DbVersionProbe None => new(null); + + /// + /// 发起后台版本探测。 + /// + /// 探测目标的标识,同一标识 + 同一连接串只探测一次(用 )。 + /// 该 provider 使用的驱动工厂,探测连接由它创建(尊重 OverrideDbProviderFactory)。 + /// 连接串;仅用于探测,不影响业务连接。 + /// + /// 由方言提供:把探测用的连接串改写成"带秒级连接超时"的版本;入参为 (原连接串, 超时秒数), + /// 返回 null 表示不改写。核心只决定"探测必须秒级返回"这个策略,怎么表达超时是方言的私有知识。 + /// + /// 探测连接的连接超时上限,覆盖连接串里的原值。 + /// 探测尝试次数;首次失败后的重试在后台进行,不增加读取侧等待。 + /// + /// 读取 前是否必须先 Open。 + /// 除 SQLite 外所有驱动在关闭连接上读该属性都会抛异常,故默认 true; + /// SQLite 传 false——它未 Open 即可读,且对其执行 Open 会在文件不存在时建出一个空库文件。 + /// + public static DbVersionProbe Start(string target, + DbProviderFactory factory, + string connectionString, + Func? prepareConnectString, + int timeoutSeconds = DefaultTimeoutSeconds, + int attempts = DefaultAttempts, + bool openBeforeRead = true) + { + var key = $"{target}|{connectionString}"; + var lazy = probes.GetOrAdd(key, _ => new Lazy( + () => StartProbe(factory, connectionString, prepareConnectString, timeoutSeconds, attempts, openBeforeRead), + LazyThreadSafetyMode.ExecutionAndPublication)); + return new DbVersionProbe(lazy.Value); + } + + /// 显式指定版本,优先级高于探测结果。 + public void Override(Version? version) + { + overridden = version; + hasOverride = true; + } + + /// 是否已显式指定版本。 + public bool HasOverride => hasOverride; + + /// 探测是否已就绪(诊断用,不做等待)。 + public bool IsResolved => hasOverride + || state is null + || state.Healed is not null + || state.First.Status == TaskStatus.RanToCompletion; + + /// + /// 版本结果。若后台探测尚未完成会等待,等待上限为一次连接超时; + /// 失败后的重试在后台进行,不占用读取侧时间。 + /// + public DbServerVersion Value + { + get + { + if (hasOverride) + { + return new DbServerVersion(null, overridden, CapabilitySource.Explicit); + } + + if (state is null) + { + return new DbServerVersion(null, null, CapabilitySource.Assumed); + } + + // 后台重试若已自愈,优先用新结果(同一连接串的所有调用方共享,见 ProbeState)。 + var healed = state.Healed; + if (healed is not null) + { + return healed.GetAwaiter().GetResult(); + } + + // First 永不 fault,故不需要 catch + return state.First.GetAwaiter().GetResult(); + } + } + + private static ProbeState StartProbe(DbProviderFactory factory, + string connectionString, + Func? prepareConnectString, + int timeoutSeconds, + int attempts, + bool openBeforeRead) + { + var first = TryOnceAsync(factory, connectionString, prepareConnectString, timeoutSeconds, openBeforeRead); + var state = new ProbeState(first); + if (attempts > 1) + { + // 启动期数据库未就绪是最常见情形,靠有限次退避重试自愈。 + _ = RetryAsync(state, factory, connectionString, prepareConnectString, timeoutSeconds, attempts, openBeforeRead); + } + return state; + } + + /// 单次探测,永不抛异常:连不上 / 驱动未实现 ServerVersion 时返回 Assumed。 + private static async Task TryOnceAsync(DbProviderFactory factory, + string connectionString, + Func? prepareConnectString, + int timeoutSeconds, + bool openBeforeRead) + { + try + { + var raw = await ReadServerVersionAsync(factory, connectionString, prepareConnectString, timeoutSeconds, openBeforeRead) + .ConfigureAwait(false); + Console.WriteLine($"database version {raw}"); + return new DbServerVersion(raw, ParseVersion(raw), CapabilitySource.Probed); + } + catch(Exception ex) + { + Console.Write("database version error "); + Console.WriteLine(ex.Message); + return new DbServerVersion(null, null, CapabilitySource.Assumed); + } + } + + private static async Task RetryAsync(ProbeState state, + DbProviderFactory factory, + string connectionString, + Func? prepareConnectString, + int timeoutSeconds, + int attempts, + bool openBeforeRead) + { + try + { + var current = await state.First.ConfigureAwait(false); + if (current.IsKnown) + { + return; + } + + for (var attempt = 2; attempt <= attempts; attempt++) + { + try + { + await Task.Delay(RetryBackoffMs * (attempt - 1)).ConfigureAwait(false); + } + catch + { + // 忽略 + } + + var next = await TryOnceAsync(factory, connectionString, prepareConnectString, timeoutSeconds, openBeforeRead) + .ConfigureAwait(false); + if (next.IsKnown) + { + state.Healed = Task.FromResult(next); + return; + } + } + } + catch + { + // 后台任务绝不外抛 + } + } + + private static async Task ReadServerVersionAsync(DbProviderFactory factory, + string connectionString, + Func? prepareConnectString, + int timeoutSeconds, + bool openBeforeRead) + { + using var conn = factory.CreateConnection() + ?? throw new InvalidOperationException($"DbProviderFactory 未能创建连接:{factory.GetType().Name}"); + conn.ConnectionString = PrepareConnectString(connectionString, prepareConnectString, timeoutSeconds); + if (openBeforeRead) + { + await conn.OpenAsync().ConfigureAwait(false); + } + return conn.ServerVersion; + } + + /// + /// 问方言"这条连接串怎么把连接超时压到秒级"——实测驱动默认超时 SqlServer 15s、其余 2~4s,太慢。 + /// 改写方式(用哪个键名 / 哪个强类型属性 / 是否值得改写)是方言的私有知识, + /// 核心只负责调用与兜底:委托为 null、返回 null 或抛异常时,一律沿用原连接串。 + /// + private static string PrepareConnectString(string connectionString, + Func? prepare, + int timeoutSeconds) + { + if (prepare is null) + { + return connectionString; + } + + try + { + return prepare(connectionString, timeoutSeconds) ?? connectionString; + } + catch + { + // 连接串本身非法等 → 不改写,探测照常进行(失败也只会得到 Assumed,不会外抛) + return connectionString; + } + } + + private static Version? ParseVersion(string? raw) + { + if (string.IsNullOrWhiteSpace(raw)) + { + return null; + } + + var match = leadingVersion.Match(raw); + if (!match.Success) + { + return null; + } + + return Version.TryParse(match.Groups[1].Value, out var version) ? version : null; + } + + /// + /// 同一 (目标, 连接串) 的共享探测状态。所有调用方共用一份, + /// 故后台自愈的结果对所有调用方可见。 + /// + private sealed class ProbeState(Task first) + { + /// 读取侧等待的目标:只含首次尝试,上限一个连接超时。 + internal Task First { get; } = first; + + /// 后台重试成功后的结果;为 null 表示尚未自愈。 + internal volatile Task? Healed; + } +} diff --git a/src/LightORM/Models/DbServerVersion.cs b/src/LightORM/Models/DbServerVersion.cs new file mode 100644 index 00000000..aa2bfe67 --- /dev/null +++ b/src/LightORM/Models/DbServerVersion.cs @@ -0,0 +1,41 @@ +namespace LightORM.Models; + +/// +/// 数据库版本的来源,优先级: > > 。 +/// +public enum CapabilitySource +{ + /// 用户显式指定,最高优先级,不做探测。 + Explicit = 0, + + /// 运行期连接数据库、读取服务端版本后得出。 + Probed = 1, + + /// 探测失败或尚未完成,版本不可信。 + Assumed = 2, +} + +/// +/// 一次数据库版本探测的结果。 +/// +/// 核心只负责"拿到版本串"这件事,不解释版本号的含义——哪个版本支持哪种写法, +/// 属于各方言自己的知识,放在 provider 里。 +/// +/// +public readonly struct DbServerVersion(string? raw, Version? parsed, CapabilitySource source) +{ + + /// 驱动报告的服务端版本原始串。各方言格式不一(SQLite "3.46.1"、PG "16.4 (Debian …)")。 + public string? Raw { get; } = raw; + + /// 从 前导数字段解析出的版本;解析不出时为 null。 + public Version? Parsed { get; } = parsed; + + public CapabilitySource Source { get; } = source; + + /// 版本是否可用(可解析)。 + public bool IsKnown => Parsed is not null; + + public override string ToString() + => $"{(Raw ?? Parsed?.ToString() ?? "unknown")} [{Source}]"; +} diff --git a/src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs b/src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs index 2599175c..d989df4a 100644 --- a/src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs +++ b/src/Providers/LightORM.Providers.Dameng/DamengTableHandler.cs @@ -5,21 +5,194 @@ namespace LightORM.Providers.Dameng; public sealed partial class DamengTableHandler(DamengTableOptions tableOptions) : BaseDatabaseHandler - { public override DamengTableOptions Options => tableOptions; + + /// + /// 列出当前用户(schema)下的表。达梦不跨 schema 自动搜索,USER_TABLES 就是当前连接的 schema。 + /// public override string GetTablesSql() { - throw new NotImplementedException(); + return """ + SELECT TABLE_NAME AS TableName + FROM USER_TABLES + ORDER BY TABLE_NAME + """; } public override string GetTableStructSql(string table) { - throw new NotImplementedException(); + var t = EscapeLiteral(table); + return $""" + SELECT + tc.COLUMN_NAME AS ColumnName, + CASE WHEN tc.DATA_TYPE = 'BLOB' AND s.SCALE = 16384 + THEN 'JSON' ELSE tc.DATA_TYPE END AS DataType, + CASE + WHEN s.TYPE$ IN ('TEXT','CLOB','BLOB','IMAGE','LONGVARCHAR','LONGVARBINARY') THEN '' + WHEN s.TYPE$ IN ('DECIMAL','NUMERIC','NUMBER','DEC') AND s.LENGTH$ > 0 THEN + TO_CHAR(s.LENGTH$) || + CASE WHEN s.SCALE > 0 AND s.SCALE < 1000 + THEN ',' || TO_CHAR(s.SCALE) ELSE '' END + WHEN s.LENGTH$ > 0 THEN TO_CHAR(s.LENGTH$) + ELSE '' + END AS Length, + CASE WHEN tc.NULLABLE = 'Y' THEN 'YES' ELSE 'NO' END AS Nullable, + NVL(tc.DATA_DEFAULT, '') AS DefaultValue, + CASE WHEN EXISTS ( + SELECT 1 + FROM USER_CONS_COLUMNS cc + JOIN USER_CONSTRAINTS c ON cc.CONSTRAINT_NAME = c.CONSTRAINT_NAME + WHERE c.CONSTRAINT_TYPE = 'P' + AND cc.TABLE_NAME = tc.TABLE_NAME + AND cc.COLUMN_NAME = tc.COLUMN_NAME + ) THEN 'YES' ELSE 'NO' END AS IsPrimaryKey, + CASE WHEN (NVL(s.INFO2, 0) & 1) = 1 THEN 'YES' ELSE 'NO' END AS IsIdentity, + NVL(cm.COMMENTS, '') AS Comments + FROM USER_TAB_COLUMNS tc + LEFT JOIN USER_COL_COMMENTS cm + ON cm.TABLE_NAME = tc.TABLE_NAME AND cm.COLUMN_NAME = tc.COLUMN_NAME + LEFT JOIN SYSOBJECTS o + ON o.NAME = tc.TABLE_NAME AND o.TYPE$ = 'SCHOBJ' AND o.SUBTYPE$ = 'UTAB' + LEFT JOIN SYSCOLUMNS s + ON s.ID = o.ID AND s.NAME = tc.COLUMN_NAME + WHERE tc.TABLE_NAME = '{t}' + ORDER BY tc.COLUMN_ID + """; } + public override bool ParseDataType(ReadedTableColumn column, out string type) { - throw new NotImplementedException(); + var dbType = column.DataType; + if (string.IsNullOrWhiteSpace(dbType)) + { + type = ""; + return false; + } + + var declared = dbType!; + var paren = declared.IndexOf('('); + if (paren >= 0) + { + // 不用 range 语法([..paren]):net462 上没有 System.Range / System.Index。 + declared = declared.Substring(0, paren); + } + + var d = declared.Trim().ToUpperInvariant(); + var isNullable = column.Nullable?.ToUpperInvariant() is "YES" or "Y" or "TRUE" or "1"; + + switch (d) + { + // ---- 整数族 ---- + case "TINYINT": + case "BYTE": + type = isNullable ? "sbyte?" : "sbyte"; + return true; + case "SMALLINT": + case "INT2": + type = isNullable ? "short?" : "short"; + return true; + case "MEDIUMINT": + case "INT": + case "INTEGER": + case "INT4": + type = isNullable ? "int?" : "int"; + return true; + case "BIGINT": + case "INT8": + type = isNullable ? "long?" : "long"; + return true; + + // ---- 位 ---- + case "BIT": + type = isNullable ? "bool?" : "bool"; + return true; + + // ---- 字符(含达梦把 NCLOB / XMLTYPE 归一化成的 TEXT)---- + case "CHAR": + case "CHARACTER": + case "NCHAR": + case "VARCHAR": + case "VARCHAR2": + case "NVARCHAR": + case "NVARCHAR2": + case "TEXT": + case "CLOB": + case "NCLOB": + case "LONGVARCHAR": + case "XMLTYPE": + // ---- JSON:GetTableStructSql 已把达梦的 BLOB 存储改写成类型名 JSON ---- + case "JSON": + case "JSONB": + type = isNullable ? "string?" : "string"; + return true; + + // ---- 定点:精度/标度在 Length 里("18,2" 或 "9"),空表示没写精度 ---- + case "DECIMAL": + case "NUMERIC": + case "NUMBER": + case "DEC": + type = NumericType(column, isNullable); + return true; + + // ---- 浮点(达梦 FLOAT 是 8 字节双精度,单精度是 REAL)---- + case "FLOAT": + case "DOUBLE": + case "DOUBLE PRECISION": + case "BINARY_DOUBLE": + type = isNullable ? "double?" : "double"; + return true; + case "REAL": + case "BINARY_FLOAT": + type = isNullable ? "float?" : "float"; + return true; + + // ---- 日期时间(达梦 DATE 带时分秒,等价 DateTime)---- + case "DATE": + case "DATETIME": + case "TIMESTAMP": + type = isNullable ? "DateTime?" : "DateTime"; + return true; + case "TIME": + type = isNullable ? "TimeOnly?" : "TimeOnly"; + return true; + + // ---- 二进制 ---- + case "BLOB": + case "BINARY": + case "VARBINARY": + case "IMAGE": + case "LONGVARBINARY": + case "RAW": + case "LONG RAW": + type = "byte[]"; + return true; + + default: + type = ""; + return false; + } } + + /// + /// 定点数的精度细分:带标度("18,2")一律 decimal;只有精度时按 + /// 4 / 9 / 18 位分档到 short / int / long; + /// 达梦的裸 NUMBER(无参)是浮点语义,给 decimal 容错 —— 给 int 遇到小数会直接失败。 + /// + private static string NumericType(ReadedTableColumn column, bool isNullable) + { + var len = column.Length; + if (!string.IsNullOrWhiteSpace(len) && int.TryParse(len!.Split(',')[0].Trim(), out var precision) && precision > 0) + { + if (len.Contains(',')) return isNullable ? "decimal?" : "decimal"; + if (precision <= 4) return isNullable ? "short?" : "short"; + if (precision <= 9) return isNullable ? "int?" : "int"; + if (precision <= 18) return isNullable ? "long?" : "long"; + } + return isNullable ? "decimal?" : "decimal"; + } + + /// 表名要放进字符串字面量,单引号必须转义成两个单引号。 + private static string EscapeLiteral(string value) => value.Replace("'", "''"); } diff --git a/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs b/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs index 24d8f379..c2128d88 100644 --- a/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs +++ b/src/Providers/LightORM.Providers.MySql/CustomMySqlAdapter.cs @@ -7,10 +7,10 @@ namespace LightORM.Providers.MySql; -#pragma warning disable CS9113 // 参数未读。 -internal sealed partial class CustomMySqlAdapter(ISqlMethodResolver methodResolver, MySqlTableOptions tableOptions) : CustomDatabaseAdapter(methodResolver), IReturnIdentity +internal sealed partial class CustomMySqlAdapter(ISqlMethodResolver methodResolver, MySqlCapabilities capabilities) : CustomDatabaseAdapter(methodResolver), IReturnIdentity { - internal static readonly CustomMySqlAdapter Instance = new(new MySqlMethodResolver(), new()); + internal static readonly CustomMySqlAdapter Instance = new(new MySqlMethodResolver(), MySqlCapabilities.Baseline); + public MySqlCapabilities Capabilities { get; } = capabilities; public override string Prefix => "?"; public override string Emphasis => "``"; public override void Paging(SelectBuilder builder, StringBuilder sql) @@ -20,35 +20,22 @@ public override void Paging(SelectBuilder builder, StringBuilder sql) public override void HandleSelectGroupBySegment(SelectContext context) { - var over8 = tableOptions.Version > new Version(8, 0); - if (over8) + if (Capabilities.Features.HasFlag(MySqlFeatures.GroupByRollup)) { base.HandleSelectGroupBySegment(context); + return; } - else + + // 8.0 以下:ROLLUP 只有旧写法 `GROUP BY (...) WITH ROLLUP`; + // CUBE / GROUPING SETS 没有替代实现 → 不判版本,走 base 生成后交给数据库报错(与"只有一种实现的函数"同一原则)。 + var builder = context.Builder; + if (builder.IsRollup) { 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(); - } + sql.Append(context.Ident).Append("GROUP BY (").Append(builder.GroupBy).AppendLine(") WITH ROLLUP"); + return; } + base.HandleSelectGroupBySegment(context); } public void ReturnIdentitySql(StringBuilder sql) => sql.Append("SELECT @@IDENTITY"); diff --git a/src/Providers/LightORM.Providers.MySql/MySqlCapabilities.cs b/src/Providers/LightORM.Providers.MySql/MySqlCapabilities.cs new file mode 100644 index 00000000..43b12481 --- /dev/null +++ b/src/Providers/LightORM.Providers.MySql/MySqlCapabilities.cs @@ -0,0 +1,85 @@ +using LightORM.Implements; +using LightORM.Models; +using MySqlConnector; + +namespace LightORM.Providers.MySql; + +/// +/// MySQL 方言随版本变化的能力位。 +/// +/// 只登记"不同版本有不同写法"的能力——同一 SQL 片段要能按版本生成两套实现,能力位才有意义。 +/// 只有一种写法的能力不进这里(例如函数索引 ((expr)) 仅 8.0.13+ 存在,5.7 没有替代写法, +/// 硬判版本只是多一条分支,交给数据库报错即可)。 +/// +/// +/// MySQL 取保守基线(版本未知 → ):旧写法 +/// (GROUP BY ... WITH ROLLUP)在 5.7 与 8.0 都能跑,而 8.0 的 ROLLUP() 语法在 5.7 直接报错, +/// 所以未知时选全版本可用的那个。 +/// +/// +[Flags] +public enum MySqlFeatures +{ + None = 0, + + /// + /// 8.0+:GROUP BY ROLLUP(...) / CUBE(...) / GROUPING SETS(...); + /// 8.0 以下只有 GROUP BY ... WITH ROLLUP 一种写法(无 CUBE / GROUPING SETS)。 + /// + GroupByRollup = 1 << 0, + + /// 完整功能位集合。 + Full = GroupByRollup, +} + +/// +/// MySQL 能力档案:把核心探测到的版本号翻译成 MySQL 自己的能力位。 +/// +public sealed class MySqlCapabilities : DbCapabilities +{ + protected override string ProbeTarget => DbBaseType.MySql.Name; + + /// + /// 用强类型 压探测超时 + /// (注意该属性是 uint,与 DefaultCommandTimeout 是两个不同属性——按"超时键名"字符串试探 + /// 区分不了两者,这正是交给方言而非核心的原因)。 + /// + protected override string? PrepareProbeConnectString(string connectionString, int timeoutSeconds) + { + try + { + var builder = new MySqlConnectionStringBuilder(connectionString) + { + ConnectionTimeout = (uint)timeoutSeconds, + }; + return builder.ConnectionString; + } + catch + { + return null; + } + } + + /// + /// 版本 → 能力位。版本不可用时返回保守基线。 + /// + /// 直接比版本分量(major = 8 即 MySQL 8.0 起),不构造 Version 实例比较。 + /// MariaDB 会伪装 "5.5.5-10.x-MariaDB" 前缀,按前导数字取到 major 5 → 自动落到保守基线 + /// (MariaDB 无 ROLLUP() 语法),与预期一致。 + /// + /// + public override MySqlFeatures MapFeatures(Version? version) + { + if (version is null) + { + return MySqlFeatures.None; + } + + var features = MySqlFeatures.None; + if (version.Major >= 8) + { + features |= MySqlFeatures.GroupByRollup; // 8.0 + } + return features; + } +} diff --git a/src/Providers/LightORM.Providers.MySql/MySqlProvider.cs b/src/Providers/LightORM.Providers.MySql/MySqlProvider.cs index c3d10d24..c30d6fb1 100644 --- a/src/Providers/LightORM.Providers.MySql/MySqlProvider.cs +++ b/src/Providers/LightORM.Providers.MySql/MySqlProvider.cs @@ -31,16 +31,24 @@ private MySqlProvider(DataBaseOption option) : base(option.Ma { throw new Exception("未能在连接字符串中发现目标数据库!"); } - DbHandler = new MySqlTableHandler(master, option.GenerateOption); + var generate = option.GenerateOption; + var factory = option.NewFactory ?? MySqlConnectorFactory.Instance; + // 版本探测在构造期发起(后台执行),使首个 SQL 构建时档案已就绪; + // 已用 TableOptions.SpecificVersion 指定版本、或 DetectVersion = false 时跳过探测(退到保守基线)。 + Capabilities = MySqlCapabilities.Start(factory, master, generate.SpecificVersion, generate.DetectVersion); + DbHandler = new MySqlTableHandler(master, generate); var sqlMethodResolver = new MySqlMethodResolver(); option.SqlMethodConfiguration?.Invoke(sqlMethodResolver); - DatabaseAdapter = new CustomMySqlAdapter(sqlMethodResolver, option.GenerateOption); + DatabaseAdapter = new CustomMySqlAdapter(sqlMethodResolver, Capabilities); DatabaseAdapter.AddKeyWord(option.Keyworks); DatabaseAdapter.UseIdentifierQuote = option.IsUseIdentifierQuote ?? true; - DbProviderFactory = option.NewFactory ?? MySqlConnectorFactory.Instance; + DbProviderFactory = factory; } public override DbBaseType DbBaseType => DbBaseType.MySql; + /// 版本能力档案(探测 / 显式指定 / 未探测时的保守基线)。 + public MySqlCapabilities Capabilities { get; } + public override IDatabaseAdapter DatabaseAdapter { get; } public override Func? TableHandler { get; } = option => throw new NotSupportedException(); diff --git a/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs b/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs index cf08ec4d..febd23de 100644 --- a/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs +++ b/src/Providers/LightORM.Providers.MySql/MySqlTableOptions.cs @@ -5,5 +5,4 @@ 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.Oracle/CustomOracleAdapter.cs b/src/Providers/LightORM.Providers.Oracle/CustomOracleAdapter.cs index 5b1e3f78..4a2e3cfe 100644 --- a/src/Providers/LightORM.Providers.Oracle/CustomOracleAdapter.cs +++ b/src/Providers/LightORM.Providers.Oracle/CustomOracleAdapter.cs @@ -12,9 +12,16 @@ namespace LightORM.Providers.Oracle; #pragma warning disable CS9113 // 参数未读。 -internal sealed partial class CustomOracleAdapter(ISqlMethodResolver methodResolver, OracleTableOptions tableOptions) : CustomDatabaseAdapter(methodResolver), IDbCommandInitializer +internal sealed partial class CustomOracleAdapter(ISqlMethodResolver methodResolver, OracleTableOptions tableOptions, OracleCapabilities capabilities) : CustomDatabaseAdapter(methodResolver), IDbCommandInitializer { - internal readonly static CustomOracleAdapter Instance = new(new OracleMethodResolver(), new()); + /// 数据库版本能力档案。构造期由 发起后台探测,此处只做读取。 + internal OracleCapabilities Capabilities => capabilities; + + /// + /// JSON 列是否走原生 JSON 类型(21c+):决定值参数用 JSON(:p) 构造器还是 :p FORMAT JSON 子句。 + /// + private bool UseJsonNativeType => capabilities.Features.HasFlag(OracleFeatures.JsonNativeType); + public override string Prefix => ":"; public override string Emphasis => "\"\""; @@ -89,10 +96,6 @@ public override void HandleJsonColumn(JsonColumnContext context) if (context.Options.SqlType == SqlPartial.Update) { // 无索引、无路径成员的 json 列引用 = 整列替换(如 Set(j => j.Data, obj))。 - // 不能走 JSON_TRANSFORM(col, SET '$' = :p): - // 1) JSON_TRANSFORM 对 NULL 输入返回 NULL, 列原值为空时值会静默丢失(与已修的 MySQL JSON_SET 同类); - // 2) SET '$' 的文本参数被当作 JSON 字符串写入, 会双重编码。 - // 与 PG / Sqlite / SqlServer / MySQL / Dameng 的整列分支保持一致, 直接列赋值。 if (!context.HasIndexInfo()) { context.Sql.AppendEmphasis(context.Column.ColumnName, this); @@ -116,14 +119,22 @@ public override void HandleJsonColumn(JsonColumnContext context) BuildJsonPath(); context.Sql.Append('\''); context.Sql.Append('='); - // 值参数须经 JSON() 构造器按 JSON 解析: JSON_TRANSFORM 的 SET 右值若是文本, Oracle 会按 - // "JSON 字符串"写入(而非解析), 而框架下发的参数是序列化后的 JSON 文本(如 "abc" / {"a":1}), - // 直接赋值会双重编码(存成 "\"abc\"")、读回带多余引号。 - // 与 SQLite 的 JSON(@p)、PG 的 @p::JSONB 语义对齐; 由 OracleMethodResolver 处理。 - context.Sql.Append("JSON("); - context.Sql.Append(Prefix); - context.Sql.Append(context.Column.PropertyName); - context.Sql.Append(')'); + // 值参数须按 JSON 解析后写入,否则直接赋值会双重编码(存成 "\"abc\"")、读回带多余引号: + // · 21c 原生 JSON 列 → JSON(:p) 构造器(21c 起才有该构造器); + // · ≤19c 文本列 → :p FORMAT JSON 子句(不依赖 JSON 类型,语义与构造器一致)。 + if (UseJsonNativeType) + { + context.Sql.Append("JSON("); + context.Sql.Append(Prefix); + context.Sql.Append(context.Column.PropertyName); + context.Sql.Append(')'); + } + else + { + context.Sql.Append(Prefix); + context.Sql.Append(context.Column.PropertyName); + context.Sql.Append(" FORMAT JSON"); + } context.Sql.Append(')'); } else diff --git a/src/Providers/LightORM.Providers.Oracle/OracleCapabilities.cs b/src/Providers/LightORM.Providers.Oracle/OracleCapabilities.cs new file mode 100644 index 00000000..17d6b659 --- /dev/null +++ b/src/Providers/LightORM.Providers.Oracle/OracleCapabilities.cs @@ -0,0 +1,92 @@ +using LightORM.Implements; +using LightORM.Models; +using Oracle.ManagedDataAccess.Client; + +namespace LightORM.Providers.Oracle; + +/// +/// Oracle 方言随版本变化的能力位。 +/// +/// 只登记"不同版本有不同写法"的能力——同一个 SQL/DDL 片段要能按版本生成两套实现,能力位才有意义。 +/// 只有一种写法的能力不进这里:低版本没有替代写法,硬判版本多一条分支,直接交给数据库报错即可。 +/// +/// +/// Oracle 取保守基线(版本未知 → ),与 SqlServer 的乐观基线相反: +/// Oracle 的能力位是"新写法在旧库直接失败"(19c 建 JSON 列报 ORA-00902、`GENERATED AS IDENTITY` +/// 在 12.1 前是语法错),所以退化到旧写法才是安全解;SqlServer 的能力位则是"新写法在旧库报错、 +/// 旧写法在新库仍可跑",故它选择乐观。 +/// +/// +[Flags] +public enum OracleFeatures +{ + None = 0, + + /// + /// 12.1+:自增列可用 GENERATED ALWAYS AS IDENTITY,否则用序列 + 触发器(两套 DDL 实现)。 + /// + IdentityColumn = 1 << 0, + + /// + /// 21c+:原生 JSON 列类型、JSON() 构造器可用(≤19c 建表即 ORA-00902 invalid datatype)。 + /// 关掉时:列类型退化 CLOB,路径更新值改由 SQL/JSON 的 FORMAT JSON 子句承载(两套写法)。 + /// + JsonNativeType = 1 << 1, +} + +/// +/// Oracle 能力档案:把核心探测到的版本号翻译成 Oracle 自己的能力位。 +/// +public sealed class OracleCapabilities : DbCapabilities +{ + protected override string ProbeTarget => DbBaseType.Oracle.Name; + + /// + /// 用强类型 压探测超时。 + /// + /// 不用"超时键名"字符串写法:Oracle 对 "Connect Timeout"/"Timeout" 报 + /// ORA-50008 invalid connection string attribute,只有 "Connection Timeout" 被接受—— + /// 这类差异写错只能在运行期发现,而强类型属性由编译器保证。 + /// + /// + protected override string? PrepareProbeConnectString(string connectionString, int timeoutSeconds) + { + try + { + var builder = new OracleConnectionStringBuilder(connectionString) + { + ConnectionTimeout = timeoutSeconds, + }; + return builder.ConnectionString; + } + catch + { + return null; + } + } + + /// + /// 版本 → 能力位。版本不可用时返回保守基线(各能力位都退到"全版本可用"的写法): + /// None = 不自增列(序列 + 触发器)+ CLOB 文本列,与引入探测前的手写默认值一致。 + /// + public override OracleFeatures MapFeatures(Version? version) + { + if (version is null) + { + return OracleFeatures.None; + } + + var features = OracleFeatures.None; + // 12.1 起支持 IDENTITY;比分量而非构造 Version 实例。注意不能用 "Major >= 12 && Minor >= 1": + // 它会漏掉 minor 为 0 的 12.1+ 版本(如 19.0)。 + if (version.Major >= 13 || (version.Major == 12 && version.Minor >= 1)) + { + features |= OracleFeatures.IdentityColumn; + } + if (version.Major >= 21) + { + features |= OracleFeatures.JsonNativeType; + } + return features; + } +} diff --git a/src/Providers/LightORM.Providers.Oracle/OracleProvider.cs b/src/Providers/LightORM.Providers.Oracle/OracleProvider.cs index 663b449b..2d290dab 100644 --- a/src/Providers/LightORM.Providers.Oracle/OracleProvider.cs +++ b/src/Providers/LightORM.Providers.Oracle/OracleProvider.cs @@ -22,14 +22,23 @@ public static OracleProvider Create(Action> s } private OracleProvider(DataBaseOption option) : base(option.MasterConnectionString!, option.SalveConnectionStrings) { - DbHandler = new OracleTableHandler(option.GenerateOption); + var generate = option.GenerateOption; var sqlMethodResolver = new OracleMethodResolver(); option.SqlMethodConfiguration?.Invoke(sqlMethodResolver); - DatabaseAdapter = new CustomOracleAdapter(sqlMethodResolver, option.GenerateOption); + DbProviderFactory = option.NewFactory ?? OracleClientFactory.Instance; + // 版本探测在构造期发起(后台执行),使首个 SQL 构建时档案已就绪; + // 已用 TableOptions.SpecificVersion 指定版本、或 DetectVersion = false 时跳过探测(退到保守基线)。 + Capabilities = OracleCapabilities.Start(DbProviderFactory, MasterConnectionString, generate.SpecificVersion, generate.DetectVersion); + // DbHandler 的 DDL 分支依赖能力档案(自增列走 IDENTITY 还是序列 + 触发器),故必须后建。 + DbHandler = new OracleTableHandler(generate, Capabilities); + DatabaseAdapter = new CustomOracleAdapter(sqlMethodResolver, generate, Capabilities); DatabaseAdapter.AddKeyWord(option.Keyworks); DatabaseAdapter.UseIdentifierQuote = option.IsUseIdentifierQuote ?? true; - DbProviderFactory = option.NewFactory ?? OracleClientFactory.Instance; } + + /// 数据库版本能力档案(同 上的那份,便于直接取用)。 + public OracleCapabilities Capabilities { get; } + public override DbBaseType DbBaseType => DbBaseType.Oracle; public override IDatabaseAdapter DatabaseAdapter { get; } diff --git a/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.Writer.cs b/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.Writer.cs index ed32a65f..95b93573 100644 --- a/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.Writer.cs +++ b/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.Writer.cs @@ -102,7 +102,7 @@ public override IEnumerable BuildTableSql(OracleTableOptions option, DbT #endregion - if (!option.OverVersion) + if (!UseIdentityColumn) { // 序列 + 触发器自增 var increments = table.Columns.Where(col => col.AutoIncrement); @@ -137,10 +137,14 @@ protected override string BuildColumn(OracleTableOptions option, DbColumn column dataType = $"{dataType}({column.Length ?? option.DefaultStringLength})"; } - string notNull = column.NotNull || column.PrimaryKey ? "NOT NULL" : "NULL"; - string identity = column.AutoIncrement && option.OverVersion ? $"GENERATED ALWAYS AS IDENTITY" : ""; + // Oracle 的身份列有两条硬约束(实测 21c): + // ① GENERATED ... AS IDENTITY 必须紧跟数据类型,写在 NOT NULL 之后报 ORA-00907; + // ② 身份列隐含 NOT NULL,显式写 NULL 报 ORA-30670 —— 故两者必须一起决定。 + bool useIdentity = column.AutoIncrement && UseIdentityColumn; + string identity = useIdentity ? " GENERATED ALWAYS AS IDENTITY" : ""; + string notNull = useIdentity || column.NotNull || column.PrimaryKey ? "NOT NULL" : "NULL"; string defaultValueClause = column.Default != null ? $" DEFAULT '{column.Default}'" : ""; - return $"{DbEmphasis(option, column.Name)} {dataType} {defaultValueClause} {notNull} {identity}"; + return $"{DbEmphasis(option, column.Name)} {dataType}{identity} {defaultValueClause} {notNull}"; } protected override string ConvertToDbType(OracleTableOptions option, DbColumn type) @@ -151,7 +155,9 @@ protected override string ConvertToDbType(OracleTableOptions option, DbColumn ty { return option.SpecificJsonColumnDbType; } - if (type.Length > 320000) + // 超长文档必须走大对象;原生 JSON 类型要 21c 起才有(≤19c 建表报 ORA-00902 invalid datatype)。 + // 退化成 CLOB 不损失功能:JSON_VALUE / JSON_QUERY / JSON_TRANSFORM 对文本列同样有效。 + if (type.Length > 320000 || !UseJsonNativeType) { return "CLOB"; } diff --git a/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.cs b/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.cs index 86d5dbf1..b8e50da0 100644 --- a/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.cs +++ b/src/Providers/LightORM.Providers.Oracle/OracleTableHandler.cs @@ -3,10 +3,24 @@ namespace LightORM.Providers.Oracle; -public sealed partial class OracleTableHandler(OracleTableOptions tableOptions) +public sealed partial class OracleTableHandler(OracleTableOptions tableOptions, OracleCapabilities capabilities) : BaseDatabaseHandler { public override OracleTableOptions Options => tableOptions; + + /// + /// 自增列是否用 GENERATED ALWAYS AS IDENTITY(12.1+)。 + /// 版本来自 (探测或 显式指定); + /// 版本未知时为 false,退化为序列 + 触发器 —— 与旧 OverVersion=false 的默认行为一致。 + /// + private bool UseIdentityColumn => capabilities.Features.HasFlag(OracleFeatures.IdentityColumn); + + /// + /// JSON 列是否用原生 JSON 类型(21c+)。关掉时退化 CLOB 文本列(≤19c 唯一可行写法)。 + /// 版本未知时为 false —— 与"探测不到版本就退到全版本可用的写法"一致。 + /// + private bool UseJsonNativeType => capabilities.Features.HasFlag(OracleFeatures.JsonNativeType); + public override string GetTablesSql() { return "select table_name TableName from user_tab_columns group by table_name order by table_name"; @@ -19,7 +33,7 @@ public override IEnumerable GetDropTableSql(DbTable table) { yield return item; } - if (!tableOptions.OverVersion) + if (!UseIdentityColumn) { // 序列 + 触发器自增 var increments = table.Columns.Where(col => col.AutoIncrement); diff --git a/src/Providers/LightORM.Providers.Oracle/OracleTableOptions.cs b/src/Providers/LightORM.Providers.Oracle/OracleTableOptions.cs index 18634a10..b5e14dfd 100644 --- a/src/Providers/LightORM.Providers.Oracle/OracleTableOptions.cs +++ b/src/Providers/LightORM.Providers.Oracle/OracleTableOptions.cs @@ -3,10 +3,6 @@ public record OracleTableOptions : TableOptions { - /// - /// 当前仅Oracle对此属性有支持,高级版本的Oracle,适用自增列语法 GENERATED ALWAYS AS IDENTITY - /// - public bool OverVersion { get; set; } public string? TableSpace { get; set; } public string? UserId { get; set; } public int? InitialLONGFetchSize { get; set; } diff --git a/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs b/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs index 9f608546..e8b44266 100644 --- a/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs +++ b/src/Providers/LightORM.Providers.SqlServer/CustomSqlServerAdapter.cs @@ -11,15 +11,15 @@ namespace LightORM.Providers.SqlServer; #pragma warning disable CS9113 // 参数未读。 -internal sealed partial class CustomSqlServerAdapter(SqlServerVersion version, ISqlMethodResolver methodResolver, SqlServerTableOptions tableOptions) : CustomDatabaseAdapter(methodResolver), IReturnIdentity +internal sealed partial class CustomSqlServerAdapter(SqlServerCapabilities capabilities, ISqlMethodResolver methodResolver, SqlServerTableOptions tableOptions) : CustomDatabaseAdapter(methodResolver), IReturnIdentity { - public SqlServerVersion Version { get; } = version; + public SqlServerCapabilities Capabilities { get; } = capabilities; public override string Prefix => "@"; public override string Emphasis => "[]"; public override void Paging(SelectBuilder builder, StringBuilder sql) { - if (Version == SqlServerVersion.Over2012) + if (Capabilities.Features.HasFlag(SqlServerFeatures.OffsetFetch)) { sql.AppendLine($"OFFSET {builder.Skip} ROWS"); sql.AppendLine($"FETCH NEXT {builder.Take} ROWS ONLY"); @@ -63,10 +63,12 @@ public override void Paging(SelectBuilder builder, StringBuilder sql) sql.Append($"AND Paging.ROWNO <= {builder.Skip + builder.Take}"); } } + public override string HandleBooleanValueForBulkCopy(bool value) { return value ? "true" : "false"; } + public void ReturnIdentitySql(StringBuilder sql) => sql.Append("SELECT SCOPE_IDENTITY()"); public override void HandleDateValue(StringBuilder sql, DateTime dateTime) diff --git a/src/Providers/LightORM.Providers.SqlServer/Extensions/IoCExtension.cs b/src/Providers/LightORM.Providers.SqlServer/Extensions/IoCExtension.cs index 8fe90d2b..7ec9bdd9 100644 --- a/src/Providers/LightORM.Providers.SqlServer/Extensions/IoCExtension.cs +++ b/src/Providers/LightORM.Providers.SqlServer/Extensions/IoCExtension.cs @@ -7,20 +7,18 @@ public static class IoCExtension { extension(IExpressionContextSetup options) { - public void UseSqlServer(SqlServerVersion version, string masterConnectString, params string[] slaveConnectStrings) - => options.UseSqlServer("MainDb", version, masterConnectString, slaveConnectStrings); - public void UseSqlServer(string? key, SqlServerVersion version, string masterConnectString, params string[] slaveConnectStrings) + // 需要指定 DbKey / 显式版本 / 关闭版本探测时,用 Action 重载: + // options.UseSqlServer(set => { set.DbKey = "Log"; set.MasterConnectionString = cs; + // set.ConfiguraSqlServer(o => o.DetectVersion = false); }); + public void UseSqlServer(string masterConnectString, params string[] slaveConnectStrings) + => options.UseSqlServer(set => { - //var provider = SqlServerProvider.Create((version), masterConnectString, slaveConnectStrings); - //options.SetDatabase(key, DbBaseType.SqlServer, provider); - UseSqlServer(options, version, set => - { - set.DbKey = key; - set.MasterConnectionString = masterConnectString; - set.SalveConnectionStrings = slaveConnectStrings; - }); - } - public void UseSqlServer(SqlServerVersion version, Action setting) + set.DbKey = "MainDb"; + set.MasterConnectionString = masterConnectString; + set.SalveConnectionStrings = slaveConnectStrings; + }); + + public void UseSqlServer(Action setting) { var dbOption = new DataBaseOption(); setting.Invoke(dbOption); @@ -28,7 +26,7 @@ public void UseSqlServer(SqlServerVersion version, Action setting) { throw new ArgumentNullException(nameof(dbOption.MasterConnectionString), "连接字符串不能为空"); } - var provider = SqlServerProvider.Create(version, dbOption); + var provider = SqlServerProvider.Create(dbOption); options.SetDatabase(dbOption.DbKey ?? "MainDb", DbBaseType.SqlServer, provider); } } diff --git a/src/Providers/LightORM.Providers.SqlServer/SqlServerCapabilities.cs b/src/Providers/LightORM.Providers.SqlServer/SqlServerCapabilities.cs new file mode 100644 index 00000000..8eba3d07 --- /dev/null +++ b/src/Providers/LightORM.Providers.SqlServer/SqlServerCapabilities.cs @@ -0,0 +1,86 @@ +using LightORM.Implements; +using LightORM.Models; +#if NET462_OR_GREATER +using System.Data.SqlClient; +#else +using Microsoft.Data.SqlClient; +#endif + +namespace LightORM.Providers.SqlServer; + +/// +/// SqlServer 方言随版本变化的能力位。 +/// +/// 只登记"不同版本有不同写法"的能力——同一个 SQL 片段要能按版本生成两套实现,能力位才有意义。 +/// 只有一种写法的能力不进这里(例如 JSON 的 JSON_VALUE/JSON_MODIFY 仅 2016+ 存在, +/// 低版本没有替代写法,硬判版本反而要多维护一条分支,直接交给数据库报错即可)。 +/// +/// +/// 已登记的两个能力都是"新写法在老版本报错、旧写法在新版本仍可跑",所以版本未知时取 +/// ——保守退化会让现代库白白用上旧语法(如 ROW_NUMBER 分页)。 +/// +/// +[Flags] +public enum SqlServerFeatures +{ + None = 0, + + /// 11.0 (2012)+:分页可用 OFFSET ... FETCH NEXT,否则退回 ROW_NUMBER 包裹。 + OffsetFetch = 1 << 0, + + /// 14.0 (2017)+:原生 TRIM(),否则 LTRIM(RTRIM())。 + TrimFunction = 1 << 1, + + /// 完整功能位集合。 + Full = OffsetFetch | TrimFunction, +} + +/// +/// SqlServer 能力档案:把核心探测到的版本号翻译成 SqlServer 自己的能力位。 +/// +public sealed class SqlServerCapabilities : DbCapabilities +{ + protected override string ProbeTarget => DbBaseType.SqlServer.Name; + + /// + /// 用强类型 压探测超时 + /// (SQL Server 驱动默认连接超时 15 秒,探测不能等这么久)。 + /// + protected override string? PrepareProbeConnectString(string connectionString, int timeoutSeconds) + { + try + { + var builder = new SqlConnectionStringBuilder(connectionString) + { + ConnectTimeout = timeoutSeconds, + }; + return builder.ConnectionString; + } + catch + { + return null; + } + } + + /// + /// 版本 → 能力位。版本不可用时按完整功能。 + /// + public override SqlServerFeatures MapFeatures(Version? version) + { + if (version is null) + { + return SqlServerFeatures.Full; + } + + var features = SqlServerFeatures.None; + if (version.Major >= 11) + { + features |= SqlServerFeatures.OffsetFetch; // 2012 + } + if (version.Major >= 14) + { + features |= SqlServerFeatures.TrimFunction; // 2017 + } + return features; + } +} diff --git a/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs b/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs index 057557fb..5b0443d2 100644 --- a/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs +++ b/src/Providers/LightORM.Providers.SqlServer/SqlServerMethodResolver.cs @@ -4,9 +4,14 @@ namespace LightORM.Providers.SqlServer; -public sealed class SqlServerMethodResolver(SqlServerVersion version) : BaseSqlMethodResolver +public sealed class SqlServerMethodResolver(SqlServerCapabilities capabilities) : BaseSqlMethodResolver { - public SqlServerVersion Version { get; } = version; + /// 不感知版本(按完整功能生成)。 + public SqlServerMethodResolver() : this(SqlServerCapabilities.Baseline) + { + } + + public SqlServerCapabilities Capabilities { get; } = capabilities; public override void ToString(IExpressionResolver resolver, MethodCallExpression methodCall) { @@ -121,9 +126,9 @@ public override void Substring(IExpressionResolver resolver, MethodCallExpressio public override void Trim(IExpressionResolver resolver, MethodCallExpression methodCall) { - if (Version == SqlServerVersion.Over2017) + if (Capabilities.Features.HasFlag(SqlServerFeatures.TrimFunction)) { - // TRIM(columnName); + // TRIM(columnName); 2017+ resolver.Sql.Append("TRIM"); resolver.Sql.Append('('); resolver.Visit(methodCall.Object); @@ -135,24 +140,6 @@ public override void Trim(IExpressionResolver resolver, MethodCallExpression met } } - //public override void Join(IExpressionResolver resolver, MethodCallExpression methodCall) - //{ - // if (Version == SqlServerVersion.Over2017) - // { - // resolver.Sql.Append("STRING_AGG("); - // resolver.Visit(methodCall.Arguments[0]); - // if (methodCall.Arguments.Count > 1) - // { - // resolver.Sql.Append(", "); - // resolver.Options.Parameterized = false; - // resolver.Visit(methodCall.Arguments[1]); - // resolver.Options.Parameterized = true; - // } - // resolver.Sql.Append(')'); - // } - // base.Join(resolver, methodCall); - //} - public override void OrderBy(IExpressionResolver resolver, MethodCallExpression methodCall) { if (methodCall.IsWindowFn()) @@ -187,10 +174,7 @@ public override void Value(IExpressionResolver resolver, MethodCallExpression me } else { - if (Version < SqlServerVersion.Over2017) - { - throw new NotSupportedException("不支持STRING_AGG函数"); - } + // STRING_AGG 只有 2017+ 一种写法、没有替代实现 → 不做版本判断,低版本交给数据库报错。 resolver.Visit(methodCall.Object); var exps = resolver.ExpStores!; var joinExp = exps["Join"]!; diff --git a/src/Providers/LightORM.Providers.SqlServer/SqlServerProvider.cs b/src/Providers/LightORM.Providers.SqlServer/SqlServerProvider.cs index 2ddd1b6e..ff0cbdef 100644 --- a/src/Providers/LightORM.Providers.SqlServer/SqlServerProvider.cs +++ b/src/Providers/LightORM.Providers.SqlServer/SqlServerProvider.cs @@ -10,19 +10,11 @@ #endif namespace LightORM.Providers.SqlServer; -public enum SqlServerVersion -{ - V1, - Over2012, - Over2017, -} - public sealed class SqlServerProvider : BaseDatabaseProvider { - public static SqlServerProvider Create(SqlServerVersion version, DataBaseOption option) - => new(version, option); + public static SqlServerProvider Create(DataBaseOption option) => new(option); - public static SqlServerProvider Create(SqlServerVersion version, Action> setting) + public static SqlServerProvider Create(Action> setting) { var dbOption = new DataBaseOption(); setting.Invoke(dbOption); @@ -30,24 +22,33 @@ public static SqlServerProvider Create(SqlServerVersion version, Action option) : base(option.MasterConnectionString!, option.SalveConnectionStrings) + private SqlServerProvider(DataBaseOption option) : base(option.MasterConnectionString!, option.SalveConnectionStrings) { - DbHandler = new SqlServerTableHandler(option.GenerateOption); - var sqlMethodResolver = new SqlServerMethodResolver(version); + var generate = option.GenerateOption; + var factory = option.NewFactory ?? SqlClientFactory.Instance; + // 能力档案先建:handler / methodResolver / adapter 都要读它。 + // 探测在构造期发起(不阻塞),结果在 SQL 生成期才被读取。 + DbProviderFactory = factory; + Capabilities = SqlServerCapabilities.Start(factory, MasterConnectionString, generate.SpecificVersion, generate.DetectVersion); + DbHandler = new SqlServerTableHandler(generate); + var sqlMethodResolver = new SqlServerMethodResolver(Capabilities); option.SqlMethodConfiguration?.Invoke(sqlMethodResolver); - DatabaseAdapter = new CustomSqlServerAdapter(version, sqlMethodResolver, option.GenerateOption); + DatabaseAdapter = new CustomSqlServerAdapter(Capabilities, sqlMethodResolver, generate); DatabaseAdapter.AddKeyWord(option.Keyworks); DatabaseAdapter.UseIdentifierQuote = option.IsUseIdentifierQuote ?? true; - DbProviderFactory = option.NewFactory ?? SqlClientFactory.Instance; - } public override DbBaseType DbBaseType => DbBaseType.SqlServer; + /// + /// 版本能力档案:由探测结果 / 推导; + /// 未启用探测、探测失败或版本未知时按完整功能。 + /// + public SqlServerCapabilities Capabilities { get; } + public override IDatabaseAdapter DatabaseAdapter { get; } public override Func? TableHandler { get; } = option => throw new NotSupportedException(); diff --git a/src/Providers/LightORM.Providers.Sqlite/CustomSqliteAdapter.cs b/src/Providers/LightORM.Providers.Sqlite/CustomSqliteAdapter.cs index 9a2ab67a..7dc3d298 100644 --- a/src/Providers/LightORM.Providers.Sqlite/CustomSqliteAdapter.cs +++ b/src/Providers/LightORM.Providers.Sqlite/CustomSqliteAdapter.cs @@ -7,12 +7,8 @@ namespace LightORM.Providers.Sqlite; -internal sealed partial class CustomSqliteAdapter(ISqlMethodResolver methodResolver, SqliteTableOptions options) : CustomDatabaseAdapter(methodResolver), IReturnIdentity +internal sealed partial class CustomSqliteAdapter(ISqlMethodResolver methodResolver, SqliteTableOptions options, SqliteCapabilities capabilities) : CustomDatabaseAdapter(methodResolver), IReturnIdentity { - /// - /// 测试用 - /// - internal readonly static CustomSqliteAdapter TestInstance = new(new SqliteMethodResolver(new()), new()); public override string Prefix => "@"; public override string Emphasis => "``"; public override void Paging(SelectBuilder builder, StringBuilder sql) @@ -26,8 +22,8 @@ public override void HandleDateValue(StringBuilder sql, DateTime dateTime) sql.Append(dateTime.ToString("yyyy-MM-dd HH:mm:ss")); } - string Extract => options.JSONBackend == JSONBackend.Binary ? "JSONB_EXTRACT" : "JSON_EXTRACT"; - string Set => options.JSONBackend == JSONBackend.Binary ? "JSONB_SET" : "JSON_SET"; + string Extract => capabilities.UseBinaryJson(options.JSONBackend) ? "JSONB_EXTRACT" : "JSON_EXTRACT"; + string Set => capabilities.UseBinaryJson(options.JSONBackend) ? "JSONB_SET" : "JSON_SET"; public override void HandleJsonColumn(JsonColumnContext context) { if (context.Options.SqlType == SqlPartial.Update) diff --git a/src/Providers/LightORM.Providers.Sqlite/SqliteCapabilities.cs b/src/Providers/LightORM.Providers.Sqlite/SqliteCapabilities.cs new file mode 100644 index 00000000..bb91ec1e --- /dev/null +++ b/src/Providers/LightORM.Providers.Sqlite/SqliteCapabilities.cs @@ -0,0 +1,77 @@ +using LightORM.Implements; +using LightORM.Models; + +namespace LightORM.Providers.Sqlite; + +/// +/// SQLite 方言随版本变化的能力位。 +/// +/// 只登记"不同版本有不同写法"的能力——SQLite 的 JSON 函数族正是这种:3.45.0 起才有 +/// jsonb_*(二进制存储,jsonb_extract / jsonb_set)与 JSONB 列,之前只有 +/// json_* 文本函数。旧版遇到 jsonb_extract 是直接报 no such function, +/// 所以这是"新写法在旧库直接失败"的能力。 +/// +/// +/// 版本未知时取完整功能(),与 SqlServer 同为乐观基线: +/// 框架其它地方(UPSERT、窗口函数)本来就假定现代 SQLite,退化反而会让 +/// DetectVersion=false 的 ToSql 场景生成出与今天不同的 SQL。 +/// +/// +[Flags] +public enum SqliteFeatures +{ + None = 0, + + /// 3.45.0+:jsonb_* 函数族与 JSONB 列可用。 + Jsonb = 1 << 0, + + /// 完整功能位集合。 + Full = Jsonb, +} + +/// +/// SQLite 能力档案:把探测到的版本号翻译成 SQLite 自己的能力位。 +/// +public sealed class SqliteCapabilities : DbCapabilities +{ + protected override string ProbeTarget => DbBaseType.Sqlite.Name; + + /// + /// SQLite 是本地文件,没有"连接超时"这个概念,连接串无需改写; + /// 且 为 false(见下),探测根本不会去建连。 + /// + protected override string? PrepareProbeConnectString(string connectionString, int timeoutSeconds) => null; + + /// + /// SQLite 未 Open 即可读 ServerVersion(实测 3.46.1 正常返回), + /// 而 Open 会在文件不存在时建出一个空库文件——纯 SQL 生成场景绝不能碰。 + /// + protected override bool OpenBeforeRead => false; + + /// + /// 版本 → 能力位。版本不可用时按完整功能(保持与引入探测前一致的 SQL 输出)。 + /// 直接比版本分量:3.45 起有 JSONB,不构造 Version 实例比较。 + /// + public override SqliteFeatures MapFeatures(Version? version) + { + if (version is null) + { + return SqliteFeatures.Full; + } + + var features = SqliteFeatures.None; + if (version.Major > 3 || (version.Major == 3 && version.Minor >= 45)) + { + features |= SqliteFeatures.Jsonb; // 3.45.0 + } + return features; + } + + /// + /// 是否使用二进制 JSON 后端:用户选了 且服务端确实支持。 + /// 老版本 SQLite(< 3.45)上没有 jsonb_*,此时退回 json_* 文本函数, + /// 让"选错后端"从运行期报错变成自动降级。 + /// + public bool UseBinaryJson(JSONBackend backend) + => backend == JSONBackend.Binary && Features.HasFlag(SqliteFeatures.Jsonb); +} diff --git a/src/Providers/LightORM.Providers.Sqlite/SqliteMethodResolver.cs b/src/Providers/LightORM.Providers.Sqlite/SqliteMethodResolver.cs index f57b5fe8..f9c77b81 100644 --- a/src/Providers/LightORM.Providers.Sqlite/SqliteMethodResolver.cs +++ b/src/Providers/LightORM.Providers.Sqlite/SqliteMethodResolver.cs @@ -5,7 +5,7 @@ namespace LightORM.Providers.Sqlite; -public sealed class SqliteMethodResolver(SqliteTableOptions tableOptions) : BaseSqlMethodResolver +public sealed class SqliteMethodResolver(SqliteTableOptions tableOptions, SqliteCapabilities capabilities) : BaseSqlMethodResolver { public override void ToString(IExpressionResolver resolver, MethodCallExpression methodCall) { @@ -186,8 +186,9 @@ public override void NullThen(IExpressionResolver resolver, MethodCallExpression resolver.Sql.Append(')'); } - string Extract => tableOptions.JSONBackend == JSONBackend.Binary ? "JSONB_EXTRACT" : "JSON_EXTRACT"; - string Set => tableOptions.JSONBackend == JSONBackend.Binary ? "JSONB_SET" : "JSON_SET"; + // jsonb_* 要 SQLite 3.45+,老版本上会 no such function,由能力档案兜底降级到 json_*。 + string Extract => capabilities.UseBinaryJson(tableOptions.JSONBackend) ? "JSONB_EXTRACT" : "JSON_EXTRACT"; + string Set => capabilities.UseBinaryJson(tableOptions.JSONBackend) ? "JSONB_SET" : "JSON_SET"; public override void JsonQuery(IExpressionResolver resolver, MethodCallExpression methodCall) { resolver.Sql.Append(Extract); diff --git a/src/Providers/LightORM.Providers.Sqlite/SqliteProvider.cs b/src/Providers/LightORM.Providers.Sqlite/SqliteProvider.cs index 40c7caf9..28550a07 100644 --- a/src/Providers/LightORM.Providers.Sqlite/SqliteProvider.cs +++ b/src/Providers/LightORM.Providers.Sqlite/SqliteProvider.cs @@ -24,17 +24,28 @@ public static SqliteProvider Create(Action> s private SqliteProvider(DataBaseOption option) : base(option.MasterConnectionString!, option.SalveConnectionStrings) { - DbHandler = new SqliteTableHandler(option.GenerateOption); - var sqlMethodResolver = new SqliteMethodResolver(option.GenerateOption); + var generate = option.GenerateOption; + var factory = option.NewFactory ?? SQLiteFactory.Instance; + // 能力档案先建:handler / methodResolver / adapter 都要读它。 + // 探测在构造期发起(不阻塞);SQLite 不 Open,故探测不会建出库文件。 + DbProviderFactory = factory; + Capabilities = SqliteCapabilities.Start(factory, MasterConnectionString, generate.SpecificVersion, generate.DetectVersion); + DbHandler = new SqliteTableHandler(generate, Capabilities); + var sqlMethodResolver = new SqliteMethodResolver(generate, Capabilities); option.SqlMethodConfiguration?.Invoke(sqlMethodResolver); - DatabaseAdapter = new CustomSqliteAdapter(sqlMethodResolver, option.GenerateOption); + DatabaseAdapter = new CustomSqliteAdapter(sqlMethodResolver, generate, Capabilities); DatabaseAdapter.AddKeyWord(option.Keyworks); DatabaseAdapter.UseIdentifierQuote = option.IsUseIdentifierQuote ?? true; - DbProviderFactory = option.NewFactory ?? SQLiteFactory.Instance; } public override DbBaseType DbBaseType => DbBaseType.Sqlite; + /// + /// 版本能力档案:由探测结果 / 推导; + /// 未启用探测、探测失败或版本未知时按完整功能。 + /// + public SqliteCapabilities Capabilities { get; } + public override DbProviderFactory DbProviderFactory { get; } public override IDatabaseAdapter DatabaseAdapter { get; } diff --git a/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.Writer.cs b/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.Writer.cs index 37cdb8d7..4396f857 100644 --- a/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.Writer.cs +++ b/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.Writer.cs @@ -70,7 +70,8 @@ protected override string ConvertToDbType(SqliteTableOptions option, DbColumn ty { if (type.IsJson && option.JSONBackend != Models.JSONBackend.NotSupport) { - if (option.JSONBackend == Models.JSONBackend.Binary) + // 只有服务端确实支持 jsonb(3.45+)才按二进制存;老版本自动退回文本。 + if (Capabilities.UseBinaryJson(option.JSONBackend)) { return "BLOB"; } @@ -101,7 +102,7 @@ protected override string ConvertToDbType(SqliteTableOptions option, DbColumn ty { return "BLOB"; } - else if (type.IsJson && option.JSONBackend == Models.JSONBackend.Binary) + else if (type.IsJson && Capabilities.UseBinaryJson(option.JSONBackend)) { return "BLOB"; } diff --git a/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs b/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs index 5405ce32..1837f5e6 100644 --- a/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs +++ b/src/Providers/LightORM.Providers.Sqlite/SqliteTableHandler.cs @@ -3,23 +3,189 @@ namespace LightORM.Providers.Sqlite; -public sealed partial class SqliteTableHandler(SqliteTableOptions generateOption) +public sealed partial class SqliteTableHandler(SqliteTableOptions generateOption, SqliteCapabilities capabilities) : BaseDatabaseHandler { + /// 版本能力档案,决定 JSON 列走 jsonb 还是 json 族。 + public SqliteCapabilities Capabilities => capabilities; + public override SqliteTableOptions Options => generateOption; + /// + /// 列出当前库的用户表。 + /// + /// SQLite 没有 schema 概念,表信息在 sqlite_master;sqlite_% 是引擎自身的表 + /// (sqlite_sequence 等),必须排除。 + /// + /// public override string GetTablesSql() { - throw new NotImplementedException(); + return """ + SELECT name AS TableName + FROM sqlite_master + WHERE type = 'table' + AND name NOT LIKE 'sqlite\_%' ESCAPE '\' + ORDER BY name + """; } public override string GetTableStructSql(string table) { - throw new NotImplementedException(); + var t = EscapeLiteral(table); + return $""" + SELECT + ti.name AS ColumnName, + ti.type AS DataType, + CASE WHEN ti."notnull" = 1 OR ti.pk > 0 THEN 'NO' ELSE 'YES' END AS Nullable, + '' AS Comments, + COALESCE(ti.dflt_value, '') AS DefaultValue, + CASE WHEN ti.pk > 0 THEN 'YES' ELSE 'NO' END AS IsPrimaryKey, + CASE WHEN instr(ti.type, '(') > 0 + THEN replace(substr(ti.type, instr(ti.type, '(') + 1), ')', '') + ELSE '' END AS Length, + CASE WHEN ti.pk > 0 + AND upper(trim(ti.type)) = 'INTEGER' + AND (SELECT COUNT(*) FROM pragma_table_info('{t}') p WHERE p.pk > 0) = 1 + THEN 'YES' ELSE 'NO' END AS IsIdentity + FROM pragma_table_info('{t}') ti + ORDER BY ti.cid + """; } public override bool ParseDataType(ReadedTableColumn column, out string type) { - throw new NotImplementedException(); + var dbType = column.DataType; + if (string.IsNullOrWhiteSpace(dbType)) + { + type = ""; + return false; + } + + var declared = dbType!; + var paren = declared.IndexOf('('); + if (paren >= 0) + { + // 不用 range 语法([..paren]):net462 上没有 System.Range / System.Index。 + declared = declared.Substring(0, paren); + } + + var d = declared.Trim().ToUpperInvariant(); + var isNullable = column.Nullable?.ToUpperInvariant() is "YES" or "Y" or "TRUE" or "1"; + + switch (d) + { + // ---- 整数族 ---- + case "TINYINT": + type = isNullable ? "sbyte?" : "sbyte"; + return true; + case "SMALLINT": + case "INT2": + type = isNullable ? "short?" : "short"; + return true; + case "MEDIUMINT": + case "INT": + case "INTEGER": + case "INT4": + type = isNullable ? "int?" : "int"; + return true; + case "BIGINT": + case "INT8": + type = isNullable ? "long?" : "long"; + return true; + case "UNSIGNED BIG INT": + type = isNullable ? "ulong?" : "ulong"; + return true; + + // ---- 布尔(SQLite 无布尔类型,按惯例用 INTEGER 存 0/1)---- + case "BOOLEAN": + case "BOOL": + type = isNullable ? "bool?" : "bool"; + return true; + + // ---- 浮点 / 定点 ---- + case "REAL": + case "DOUBLE": + case "DOUBLE PRECISION": + type = isNullable ? "double?" : "double"; + return true; + case "FLOAT": + type = isNullable ? "float?" : "float"; + return true; + case "NUMERIC": + case "DECIMAL": + type = isNullable ? "decimal?" : "decimal"; + return true; + + // ---- 文本 ---- + case "TEXT": + case "CLOB": + case "CHAR": + case "CHARACTER": + case "VARCHAR": + case "NCHAR": + case "NVARCHAR": + case "VARYING CHARACTER": + case "NATIVE CHARACTER": + case "JSON": + type = isNullable ? "string?" : "string"; + return true; + + // ---- 日期时间(SQLite 无专用类型,按声明名约定)---- + case "DATE": + type = isNullable ? "DateOnly?" : "DateOnly"; + return true; + case "DATETIME": + case "TIMESTAMP": + type = isNullable ? "DateTime?" : "DateTime"; + return true; + case "TIME": + type = isNullable ? "TimeOnly?" : "TimeOnly"; + return true; + + // ---- 二进制 ---- + case "BLOB": + case "BINARY": + case "VARBINARY": + type = "byte[]"; + return true; + + // ---- 其它常见别名 ---- + case "UUID": + case "GUID": + case "UNIQUEIDENTIFIER": + type = isNullable ? "Guid?" : "Guid"; + return true; + + // 未命中精确表 → 按亲和性关键字兜底(顺序遵循 SQLite 官方规则) + default: + if (d.Contains("INT")) + { + type = isNullable ? "int?" : "int"; + return true; + } + if (d.Contains("CHAR") || d.Contains("CLOB") || d.Contains("TEXT")) + { + type = isNullable ? "string?" : "string"; + return true; + } + if (d.Contains("BLOB")) + { + type = "byte[]"; + return true; + } + if (d.Contains("REAL") || d.Contains("FLOA") || d.Contains("DOUB")) + { + type = isNullable ? "double?" : "double"; + return true; + } + type = isNullable ? "object?" : "object"; + return false; + } } -} \ No newline at end of file + + /// + /// 表名要放进字符串字面量(pragma_table_info('...')),单引号必须转义成两个单引号, + /// 否则名字里带引号的表会把查询拆坏。 + /// + private static string EscapeLiteral(string value) => value.Replace("'", "''"); +} diff --git a/src/versions.props b/src/versions.props index 6de7db42..41367e1b 100644 --- a/src/versions.props +++ b/src/versions.props @@ -1,46 +1,46 @@  - 2026.09.05.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.09.07.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.08.31.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 - 2026.09.05.1 + 2026.09.18.1 \ No newline at end of file diff --git a/test.db b/test.db index 9be7e19c..4526c04c 100644 Binary files a/test.db and b/test.db differ diff --git a/test/LightORMTest.Oracle/SqlGenerate/InsertOrUpdateTest.cs b/test/LightORMTest.Oracle/SqlGenerate/InsertOrUpdateTest.cs index 2d9cf6ef..63fc605f 100644 --- a/test/LightORMTest.Oracle/SqlGenerate/InsertOrUpdateTest.cs +++ b/test/LightORMTest.Oracle/SqlGenerate/InsertOrUpdateTest.cs @@ -10,10 +10,11 @@ protected override void Configura(IExpressionContextSetup option) option.UseOracle(c => { c.MasterConnectionString = ConnectString.Value; - c.ConfigureOracle(t => - { - t.OverVersion = true; - }); + //c.ConfigureOracle(t => + //{ + // // 21c:自增列可用 GENERATED ALWAYS AS IDENTITY(等效于旧的 OverVersion = true) + // t.SpecificVersion = new Version(21, 3, 0, 0); + //}); }); option.UseInterceptor(); } diff --git a/test/LightORMTest.Oracle/SqlGenerate/InsertSql.cs b/test/LightORMTest.Oracle/SqlGenerate/InsertSql.cs index 4faa1e17..9fac05a1 100644 --- a/test/LightORMTest.Oracle/SqlGenerate/InsertSql.cs +++ b/test/LightORMTest.Oracle/SqlGenerate/InsertSql.cs @@ -7,7 +7,14 @@ public class InsertSql : LightORMTest.SqlGenerate.InsertSql protected override void Configura(IExpressionContextSetup option) { - option.UseOracle(ConnectString.Value); + option.UseOracle(static c => + { + c.MasterConnectionString = ConnectString.Value; + c.ConfigureOracle(t => + { + t.DetectVersion = false; + }); + }); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/BulkCopyTest.cs b/test/LightORMTest.SqlServer/BulkCopyTest.cs index 50bdd17c..1d2e5a9e 100644 --- a/test/LightORMTest.SqlServer/BulkCopyTest.cs +++ b/test/LightORMTest.SqlServer/BulkCopyTest.cs @@ -7,7 +7,7 @@ public class BulkCopyTest : LightORMTest.BulkCopyTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/CreateTableTest.cs b/test/LightORMTest.SqlServer/CreateTableTest.cs index 87c8bfe1..87174de5 100644 --- a/test/LightORMTest.SqlServer/CreateTableTest.cs +++ b/test/LightORMTest.SqlServer/CreateTableTest.cs @@ -7,7 +7,7 @@ public class CreateTableTest : LightORMTest.CreateTableTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/DbMethodTest.cs b/test/LightORMTest.SqlServer/DbMethodTest.cs index 93dc87f1..deddd3dc 100644 --- a/test/LightORMTest.SqlServer/DbMethodTest.cs +++ b/test/LightORMTest.SqlServer/DbMethodTest.cs @@ -7,7 +7,7 @@ public class DbMethodTest : LightORMTest.DbMethodTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } } \ No newline at end of file diff --git a/test/LightORMTest.SqlServer/RepositoryTest.cs b/test/LightORMTest.SqlServer/RepositoryTest.cs index 28410e97..7082d315 100644 --- a/test/LightORMTest.SqlServer/RepositoryTest.cs +++ b/test/LightORMTest.SqlServer/RepositoryTest.cs @@ -7,7 +7,7 @@ public class RepositoryTest : LightORMTest.RepositoryTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/ResultTest/ExecutionTest.cs b/test/LightORMTest.SqlServer/ResultTest/ExecutionTest.cs index eb684c12..0f8b66b7 100644 --- a/test/LightORMTest.SqlServer/ResultTest/ExecutionTest.cs +++ b/test/LightORMTest.SqlServer/ResultTest/ExecutionTest.cs @@ -7,15 +7,8 @@ public class ExecutionTest : LightORMTest.ResultTest.ExecutionTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.Over2017, ConnectString.Value); - //option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, o => - //{ - // o.MasterConnectionString = ConnectString.Value; - // o.ConfiguraSqlServer(t => - // { - // t.UseUnicodeString = false; - // }); - //}); + // 不指定版本:由后台探测决定(真库)。需固定版本用 o.SpecificVersion,需跳过探测用 o.DetectVersion = false。 + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/ResultTest/Select.cs b/test/LightORMTest.SqlServer/ResultTest/Select.cs index cd23497e..656f983b 100644 --- a/test/LightORMTest.SqlServer/ResultTest/Select.cs +++ b/test/LightORMTest.SqlServer/ResultTest/Select.cs @@ -9,7 +9,7 @@ public class Select : LightORMTest.ResultTest.ExecutionTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + option.UseSqlServer(ConnectString.Value); option.UseInterceptor(); } diff --git a/test/LightORMTest.SqlServer/SqlGenerate/InsertOrUpdateTest.cs b/test/LightORMTest.SqlServer/SqlGenerate/InsertOrUpdateTest.cs index 2bea8e2f..76723617 100644 --- a/test/LightORMTest.SqlServer/SqlGenerate/InsertOrUpdateTest.cs +++ b/test/LightORMTest.SqlServer/SqlGenerate/InsertOrUpdateTest.cs @@ -7,7 +7,12 @@ public class InsertOrUpdateTest : LightORMTest.SqlGenerate.InsertOrUpdateTest protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + // 纯 SQL 生成,不连库:关闭版本探测,按完整功能生成。 + option.UseSqlServer(set => + { + set.MasterConnectionString = ConnectString.Value; + set.ConfiguraSqlServer(o => o.DetectVersion = false); + }); option.UseInterceptor(); } } \ No newline at end of file diff --git a/test/LightORMTest.SqlServer/SqlGenerate/InsertSql_Json.cs b/test/LightORMTest.SqlServer/SqlGenerate/InsertSql_Json.cs index fe350a7f..42b103a9 100644 --- a/test/LightORMTest.SqlServer/SqlGenerate/InsertSql_Json.cs +++ b/test/LightORMTest.SqlServer/SqlGenerate/InsertSql_Json.cs @@ -7,7 +7,12 @@ public class InsertSql_Json : LightORMTest.SqlGenerate.InsertSql_Json protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + // 纯 SQL 生成,不连库:关闭版本探测,按完整功能生成。 + option.UseSqlServer(set => + { + set.MasterConnectionString = ConnectString.Value; + set.ConfiguraSqlServer(o => o.DetectVersion = false); + }); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/SqlGenerate/SelectSql.cs b/test/LightORMTest.SqlServer/SqlGenerate/SelectSql.cs index bc3c8b1e..4efacf9c 100644 --- a/test/LightORMTest.SqlServer/SqlGenerate/SelectSql.cs +++ b/test/LightORMTest.SqlServer/SqlGenerate/SelectSql.cs @@ -7,7 +7,12 @@ public class SelectSql : LightORMTest.SqlGenerate.SelectSql protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + // 纯 SQL 生成,不连库:关闭版本探测,按完整功能生成。 + option.UseSqlServer(set => + { + set.MasterConnectionString = ConnectString.Value; + set.ConfiguraSqlServer(o => o.DetectVersion = false); + }); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/SqlGenerate/SelectSql_Json.cs b/test/LightORMTest.SqlServer/SqlGenerate/SelectSql_Json.cs index 800dde15..c281ff8b 100644 --- a/test/LightORMTest.SqlServer/SqlGenerate/SelectSql_Json.cs +++ b/test/LightORMTest.SqlServer/SqlGenerate/SelectSql_Json.cs @@ -7,7 +7,12 @@ public class SelectSql_Json : LightORMTest.SqlGenerate.SelectSql_Json protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + // 纯 SQL 生成,不连库:关闭版本探测,按完整功能生成。 + option.UseSqlServer(set => + { + set.MasterConnectionString = ConnectString.Value; + set.ConfiguraSqlServer(o => o.DetectVersion = false); + }); option.UseInterceptor(); } } diff --git a/test/LightORMTest.SqlServer/SqlGenerate/UpdateSql_Json.cs b/test/LightORMTest.SqlServer/SqlGenerate/UpdateSql_Json.cs index ef61d716..84800073 100644 --- a/test/LightORMTest.SqlServer/SqlGenerate/UpdateSql_Json.cs +++ b/test/LightORMTest.SqlServer/SqlGenerate/UpdateSql_Json.cs @@ -7,7 +7,12 @@ public class UpdateSql_Json : LightORMTest.SqlGenerate.UpdateSql_Json protected override void Configura(IExpressionContextSetup option) { - option.UseSqlServer(LightORM.Providers.SqlServer.SqlServerVersion.V1, ConnectString.Value); + // 纯 SQL 生成,不连库:关闭版本探测,按完整功能生成。 + option.UseSqlServer(set => + { + set.MasterConnectionString = ConnectString.Value; + set.ConfiguraSqlServer(o => o.DetectVersion = false); + }); option.UseInterceptor(); } } diff --git a/test/LightORMTest/ExpressionTest/ConstantExpressionTest.cs b/test/LightORMTest/ExpressionTest/ConstantExpressionTest.cs index 08f733c0..0fc46432 100644 --- a/test/LightORMTest/ExpressionTest/ConstantExpressionTest.cs +++ b/test/LightORMTest/ExpressionTest/ConstantExpressionTest.cs @@ -1,4 +1,6 @@ -using LightORM.Utils; +using LightORM.Providers.Sqlite.Extensions; +using LightORM.Utils; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; namespace LightORMTest.ExpressionTest; @@ -6,11 +8,23 @@ namespace LightORMTest.ExpressionTest; [TestClass] public class ConstantExpressionTest { + [NotNull] public ResolveContext? Context { get; set; } + + [TestInitialize] + public void InitResolveContext() + { + Context = new(LightORM.Providers.Sqlite.SqliteProvider.Create(o => + { + o.MasterConnectionString = "Data Source=:memory:;Version=3;New=True;"; + o.ConfiguraSqlite(t => t.DetectVersion = false); + }).DatabaseAdapter); + } + [TestMethod] public void TestConstantNullValue() { Expression> exp = u => u.Age == null; - var result = exp.Resolve(SqlResolveOptions.Where, new ResolveContext(LightORM.Providers.Sqlite.CustomSqliteAdapter.TestInstance)); + var result = exp.Resolve(SqlResolveOptions.Where, Context); Console.WriteLine(result.SqlString); Assert.AreEqual("(`a`.`AGE` IS NULL)", result.SqlString); } @@ -18,15 +32,14 @@ public void TestConstantNullValue() [TestMethod] public void TestVaribleValue() { - var resolveCtx = new ResolveContext(LightORM.Providers.Sqlite.CustomSqliteAdapter.TestInstance); var resolveOption = SqlResolveOptions.Where; var age = 10; Expression> exp = u => u.Age > age; - var result = exp.Resolve(resolveOption, resolveCtx); + var result = exp.Resolve(resolveOption, Context); Console.WriteLine(result.SqlString); Assert.AreEqual("(`a`.`AGE` > age_0_0)", result.SqlString); - var p = ExpressionValueExtract.Default.Extract(exp, resolveOption, resolveCtx); + var p = ExpressionValueExtract.Default.Extract(exp, resolveOption, Context); Assert.AreEqual("age_0_0", p[0].Name); } } diff --git a/test/LightORMTest/ExpressionTest/FormatStringTest.cs b/test/LightORMTest/ExpressionTest/FormatStringTest.cs index 8400d668..670f9dea 100644 --- a/test/LightORMTest/ExpressionTest/FormatStringTest.cs +++ b/test/LightORMTest/ExpressionTest/FormatStringTest.cs @@ -1,11 +1,24 @@ using LightORM.Providers.Sqlite; +using LightORM.Providers.Sqlite.Extensions; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; namespace LightORMTest.ExpressionTest; [TestClass] -public class FormatStringTest +public class FormatStringTest { + [NotNull] public ResolveContext? Context { get; set; } + + [TestInitialize] + public void InitResolveContext() + { + Context = new(SqliteProvider.Create(o => + { + o.MasterConnectionString = "Data Source=:memory:;Version=3;New=True;"; + o.ConfiguraSqlite(t => t.DetectVersion = false); + }).DatabaseAdapter); + } private static void HandleExpressionParameters(ResolveContext context, LambdaExpression lambda) { for (int i = 0; i < lambda.Parameters.Count; i++) @@ -21,9 +34,8 @@ public void InterpolationFormat() var name = "test"; var seq = 0; Expression> exp = u => u.UserName == $"{name}{seq}"; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Where, ctx); + HandleExpressionParameters(Context, exp); + var result = exp.Resolve(SqlResolveOptions.Where, Context); Console.WriteLine(result.SqlString); } @@ -31,9 +43,8 @@ public void InterpolationFormat() public void InterpolationFormatOption() { Expression> exp = u => u.UserName == $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}"; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Where, ctx); + HandleExpressionParameters(Context, exp); + var result = exp.Resolve(SqlResolveOptions.Where, Context); Console.WriteLine(result.SqlString); } } diff --git a/test/LightORMTest/ResolverTest/ValueResolveTest.cs b/test/LightORMTest/ResolverTest/ValueResolveTest.cs index c2363297..d1b502a2 100644 --- a/test/LightORMTest/ResolverTest/ValueResolveTest.cs +++ b/test/LightORMTest/ResolverTest/ValueResolveTest.cs @@ -1,4 +1,6 @@ using LightORM.Providers.Sqlite; +using LightORM.Providers.Sqlite.Extensions; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; namespace LightORMTest.ResolverTest; @@ -6,6 +8,17 @@ namespace LightORMTest.ResolverTest; [TestClass] public class ValueResolveTest { + [NotNull] public ResolveContext? Context { get; set; } + + [TestInitialize] + public void InitResolveContext() + { + Context = new(LightORM.Providers.Sqlite.SqliteProvider.Create(o => + { + o.MasterConnectionString = "Data Source=:memory:;Version=3;New=True;"; + o.ConfiguraSqlite(t => t.DetectVersion = false); + }).DatabaseAdapter); + } class Pa(int a) { public int A => a; @@ -15,12 +28,12 @@ public void ResolveVariable() { Test(new(10)); Test(new(20)); - static void Test(Pa a) + + void Test(Pa a) { var p = "ad"; Expression> where = u => u.Age > a.A && u.UserName.Contains(p); - var context = new ResolveContext(CustomSqliteAdapter.TestInstance); - var result = where.Resolve(SqlResolveOptions.Where, context); + var result = where.Resolve(SqlResolveOptions.Where, Context); Assert.IsNotNull(result.ResolvedValues); Assert.HasCount(2, result.ResolvedValues); Assert.AreEqual(a.A, result.ResolvedValues[0].Value); @@ -34,15 +47,12 @@ public void ResolveArray() int[] arr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]; int? i = GetIndex(); var ii = new { index = 5 }; - - var context = new ResolveContext(CustomSqliteAdapter.TestInstance); - Expression> where1 = u => u.Age == arr[i.Value]; - var nullableInt = where1.Resolve(SqlResolveOptions.Where, context); + var nullableInt = where1.Resolve(SqlResolveOptions.Where, Context); Assert.AreEqual(7, nullableInt.ResolvedValues![0].Value); Expression> where2 = u => u.Age == arr[ii.index]; - var anonymous = where2.Resolve(SqlResolveOptions.Where, context); + var anonymous = where2.Resolve(SqlResolveOptions.Where, Context); Assert.AreEqual(5, anonymous.ResolvedValues![0].Value); static int GetIndex() @@ -58,12 +68,9 @@ public void ResolveCacheTest() int? i = GetIndex(); string s = "ad"; var ii = new { index = 5 }; - - var context = new ResolveContext(CustomSqliteAdapter.TestInstance); - Expression> withVariable = u => u.Age > arr[i.Value] && u.Age < arr[ii.index] && u.UserName.Contains(s); - var result1 = withVariable.Resolve(SqlResolveOptions.Where, context); - var result2 = withVariable.Resolve(SqlResolveOptions.Where, context); + var result1 = withVariable.Resolve(SqlResolveOptions.Where, Context); + var result2 = withVariable.Resolve(SqlResolveOptions.Where, Context); Assert.IsNotNull(result1.ResolvedValues); Assert.IsNotNull(result2.ResolvedValues); Assert.AreEqual(7, result1.ResolvedValues[0].Value); @@ -78,8 +85,8 @@ public void ResolveCacheTest() } Expression> noVariable = u => u.Age > 7 && u.Age < 18 && u.UserName.Contains("123"); - var result3 = noVariable.Resolve(SqlResolveOptions.Where, context); - var result4 = noVariable.Resolve(SqlResolveOptions.Where, context); + var result3 = noVariable.Resolve(SqlResolveOptions.Where, Context); + var result4 = noVariable.Resolve(SqlResolveOptions.Where, Context); Assert.IsNull(result3.ResolvedValues); Assert.IsNull(result4.ResolvedValues); static int GetIndex() @@ -92,10 +99,9 @@ static int GetIndex() public void ResolveCacheArrayContain() { int[] arr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]; - var context = new ResolveContext(CustomSqliteAdapter.TestInstance); Expression> inArray = u => arr.Contains(u.Age!.Value); - var result1 = inArray.Resolve(SqlResolveOptions.Where, context); - var result2 = inArray.Resolve(SqlResolveOptions.Where, context); + var result1 = inArray.Resolve(SqlResolveOptions.Where, Context); + var result2 = inArray.Resolve(SqlResolveOptions.Where, Context); Assert.IsNotNull(result1.ResolvedValues); Assert.IsNotNull(result2.ResolvedValues); for (int j = 0; j < result1.ResolvedValues.Count; j++) diff --git a/test/TestProject1/DataHelper.cs b/test/TestProject1/DataHelper.cs deleted file mode 100644 index 648df58b..00000000 --- a/test/TestProject1/DataHelper.cs +++ /dev/null @@ -1,26 +0,0 @@ -namespace TestProject1 -{ - internal class DataHelper - { - static readonly DateTime startDate = new DateTime(1970, 1, 1, 0, 0, 0, 0); - static long CurrentTimestampSeconds() => Convert.ToInt64((DateTime.UtcNow - startDate).TotalSeconds); - public static List GetProductList(int count = 100) - { - var list = new List(); - for (int i = 1; i <= count; i++) - { - list.Add(new Product() - { - ProductId = i, - CategoryId = 1, - ProductCode = $"测试编号_{CurrentTimestampSeconds()}_{i}", - ProductName = $"测试名称_{CurrentTimestampSeconds()}_{i}", - CreateTime = DateTime.Now, - ModifyTime = DateTime.Now, - - }); - } - return list; - } - } -} diff --git a/test/TestProject1/ExpressionTest/ConditionalTest.cs b/test/TestProject1/ExpressionTest/ConditionalTest.cs deleted file mode 100644 index b875b095..00000000 --- a/test/TestProject1/ExpressionTest/ConditionalTest.cs +++ /dev/null @@ -1,19 +0,0 @@ -using LightORM.Providers.Sqlite; -using System.Linq.Expressions; - -namespace TestProject1.ExpressionTest -{ - [TestClass] - public class ConditionalTest : TestBase - { - [TestMethod] - public void Test() - { - Expression> exp = u => u.Age > 10 ? 1 : null; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - } -} diff --git a/test/TestProject1/ExpressionTest/ConstraintTest.cs b/test/TestProject1/ExpressionTest/ConstraintTest.cs deleted file mode 100644 index 7d89c3fa..00000000 --- a/test/TestProject1/ExpressionTest/ConstraintTest.cs +++ /dev/null @@ -1,54 +0,0 @@ -using System.Linq.Expressions; - -namespace TestProject1.ExpressionTest; - -[TestClass] -public class ConstraintTest : TestBase -{ - [TestMethod] - public void ConstraintValue() - { - Expression> where = u => u.UserName.Contains("Hello"); - HandleExpressionParameters(ResolveCtx, where); - var result = where.Resolve(SqlResolveOptions.Where, ResolveCtx); - Console.WriteLine(result.SqlString); - } - [TestMethod] - public void VariableValue() - { - var key = "Hello"; - Expression> where = u => u.UserName.Contains(key); - HandleExpressionParameters(ResolveCtx, where); - var result = where.Resolve(SqlResolveOptions.Where, ResolveCtx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void ConstraintValues() - { - string[] names = ["S1", "S2"]; - Expression> where = u => u.UserName.In("S1", "S2"); - HandleExpressionParameters(ResolveCtx, where); - var result = where.Resolve(SqlResolveOptions.Where, ResolveCtx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void BooleanValueTest() - { - Expression> where = u => u.IsLock == true; - HandleExpressionParameters(ResolveCtx, where); - var result = where.Resolve(SqlResolveOptions.Where, ResolveCtx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void BooleanValueTest2() - { - var b = "12345".Length > 4; - Expression> where = u => u.IsLock == b; - HandleExpressionParameters(ResolveCtx, where); - var result = where.Resolve(SqlResolveOptions.Where, ResolveCtx); - Console.WriteLine(result.SqlString); - } -} diff --git a/test/TestProject1/ExpressionTest/InsertExpressionTest.cs b/test/TestProject1/ExpressionTest/InsertExpressionTest.cs deleted file mode 100644 index d030fe5e..00000000 --- a/test/TestProject1/ExpressionTest/InsertExpressionTest.cs +++ /dev/null @@ -1,18 +0,0 @@ -using LightORM.Providers.Sqlite; -using System.Linq.Expressions; - -namespace TestProject1.ExpressionTest; - -[TestClass] -public class InsertExpressionTest : TestBase -{ - [TestMethod] - public void Insert() - { - Expression> exp = u => u; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Insert, ctx); - Console.WriteLine(result.SqlString); - } -} diff --git a/test/TestProject1/ExpressionTest/SelectExpressionTest.cs b/test/TestProject1/ExpressionTest/SelectExpressionTest.cs deleted file mode 100644 index 9591f0a3..00000000 --- a/test/TestProject1/ExpressionTest/SelectExpressionTest.cs +++ /dev/null @@ -1,37 +0,0 @@ -using LightORM.Utils.Vistors; -using System.Linq.Expressions; - -namespace TestProject1.ExpressionTest; - -[TestClass] -public class SelectExpressionTest : TestBase -{ - //TestTableContext tableContext = new TestTableContext(); - [TestMethod] - public void SelectAll() - { - Expression> select = p => p; - var table = TestTableContext.TestProject1_Models_Product; - var result = select.Resolve(SqlResolveOptions.Select, ResolveCtx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void SelectColumn() - { - Expression> select = p => new { p.ProductId, p.ProductName }; - var table = TestTableContext.TestProject1_Models_Product; - var result = select.Resolve(SqlResolveOptions.Select, ResolveCtx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void SelectFromTypeSet() - { - Expression, object>> select = p => new { p.Tb1.ProductId, p.Tb2.UserId }; - var t1 = TestTableContext.TestProject1_Models_Product; - var t2 = TestTableContext.TestProject1_Models_User; - var result = FlatTypeSet.Default.Flat(select).Resolve(SqlResolveOptions.Select, ResolveCtx); - Console.WriteLine(result.SqlString); - } -} diff --git a/test/TestProject1/FlatSqlTest/SelectTest.cs b/test/TestProject1/FlatSqlTest/SelectTest.cs deleted file mode 100644 index dbe677a0..00000000 --- a/test/TestProject1/FlatSqlTest/SelectTest.cs +++ /dev/null @@ -1,24 +0,0 @@ -namespace TestProject1.FlatSqlTest; - -[TestClass] -public class SelectTest : TestBase -{ - [TestMethod] - public void SelectFlat() - { - var u = Db.Select() - .Where(u => u.UserId == "admin") - .First(); - Assert.IsTrue(u?.PriInfo.Age == 6); - } - - [TestMethod] - public void Select_Flat_Where() - { - var u = Db.Select() - .Where(u => u.PriInfo.Age == 6) - .First(); - Assert.IsTrue(u?.UserId == "admin"); - - } -} diff --git a/test/TestProject1/GlobalUsings.cs b/test/TestProject1/GlobalUsings.cs deleted file mode 100644 index ebba7c7b..00000000 --- a/test/TestProject1/GlobalUsings.cs +++ /dev/null @@ -1,3 +0,0 @@ -global using Microsoft.VisualStudio.TestTools.UnitTesting; -global using TestProject1.Models; -global using LightORM; \ No newline at end of file diff --git a/test/TestProject1/Models/Power.cs b/test/TestProject1/Models/Power.cs deleted file mode 100644 index 94d33d8e..00000000 --- a/test/TestProject1/Models/Power.cs +++ /dev/null @@ -1,69 +0,0 @@ -using System.ComponentModel.DataAnnotations; -using System.ComponentModel.DataAnnotations.Schema; -#nullable disable -namespace TestProject1.Models; - -public enum PowerType -{ - [Display(Name = "页面")] - Page, - [Display(Name = "按钮")] - Button -} - -public interface IPower -{ - string PowerId { get; set; } - string PowerName { get; set; } - string ParentId { get; set; } - PowerType PowerType { get; set; } - int PowerLevel { get; set; } - string Icon { get; set; } - string Path { get; set; } - int Sort { get; set; } - bool GenerateCRUDButton { get; set; } - IEnumerable Children { get; set; } -} - -[LightTable(Name = "POWERS")] -public class Power : IPower -{ - [LightColumn(Name = "ID", PrimaryKey = true)] - public int Id { get; set; } - [Required] - [LightColumn(Name = "POWER_ID", PrimaryKey = true)] - public string PowerId { get; set; } - [Required] - [LightColumn(Name = "POWER_NAME")] - public string PowerName { get; set; } - [Required] - [LightColumn(Name = "PARENT_ID")] - public string ParentId { get; set; } - [Required] - [LightColumn(Name = "POWER_TYPE")] - public PowerType PowerType { get; set; } - - [LightColumn(Name = "POWER_LEVEL")] - public int PowerLevel { get; set; } - - [LightColumn(Name = "ICON")] - public string Icon { get; set; } - [LightColumn(Name = "PATH")] - public string Path { get; set; } - [LightColumn(Name = "SORT")] - public int Sort { get; set; } - - [LightNavigateAttribute(typeof(RolePower), nameof(PowerId), nameof(RolePower.PowerId))] - public IEnumerable Roles { get; set; } - - //[LightNavigate(typeof())] - //public ICollection Users { get; set; } - - [LightNavigateAttribute(nameof(PowerId), nameof(ParentId))] - public IEnumerable Children { get; set; } - - - [NotMapped] - public bool GenerateCRUDButton { get; set; } - IEnumerable IPower.Children { get => Children; set => Children = value.Cast().ToList(); } -} diff --git a/test/TestProject1/Models/Product.cs b/test/TestProject1/Models/Product.cs deleted file mode 100644 index 0e26b789..00000000 --- a/test/TestProject1/Models/Product.cs +++ /dev/null @@ -1,28 +0,0 @@ -namespace TestProject1.Models; - -/// -/// 产品 -/// -[LightTable] -public class Product -{ - [LightColumn(PrimaryKey = true)] - public int ProductId { get; set; } - - public int CategoryId { get; set; } - - public string ProductCode { get; set; } = string.Empty; - - public string ProductName { get; set; } = string.Empty; - - public bool DeleteMark { get; set; } - - public DateTime CreateTime { get; init; } = DateTime.Now; - - public DateTime? ModifyTime { get; set; } - public DateTime? Last { get; set; } = DateTime.Now; - [LightORM.Ignore] - public IEnumerable Products { get; set; } = []; - [LightORM.Ignore] - public Product[] Products2 { get; set; } = []; -} \ No newline at end of file diff --git a/test/TestProject1/Models/Role.cs b/test/TestProject1/Models/Role.cs deleted file mode 100644 index 51ca1a35..00000000 --- a/test/TestProject1/Models/Role.cs +++ /dev/null @@ -1,16 +0,0 @@ -namespace TestProject1.Models; - -[LightTable(Name = "ROLE")] -public class Role -{ - [LightColumn(Name = "ROLE_ID", PrimaryKey = true)] - public string RoleId { get; set; } - [LightColumn(Name = "ROLE_NAME")] - public string RoleName { get; set; } - - [LightNavigate(ManyToMany = typeof(UserRole), MainName = nameof(RoleId), SubName = nameof(UserRole.RoleId))] - public IEnumerable Users { get; set; } - - [LightNavigate(ManyToMany =typeof(RolePower), MainName = nameof(RoleId), SubName = nameof(RolePower.RoleId))] - public IEnumerable Powers { get; set; } -} diff --git a/test/TestProject1/Models/RolePower.cs b/test/TestProject1/Models/RolePower.cs deleted file mode 100644 index e5e9107c..00000000 --- a/test/TestProject1/Models/RolePower.cs +++ /dev/null @@ -1,11 +0,0 @@ -namespace TestProject1.Models; - - -[LightTable(Name = "ROLE_POWER")] -public class RolePower -{ - [LightColumn(Name = "ROLE_ID", PrimaryKey = true)] - public string RoleId { get; set; } - [LightColumn(Name = "POWER_ID", PrimaryKey = true)] - public string PowerId { get; set; } -} diff --git a/test/TestProject1/Models/RunLog.cs b/test/TestProject1/Models/RunLog.cs deleted file mode 100644 index e4af49fe..00000000 --- a/test/TestProject1/Models/RunLog.cs +++ /dev/null @@ -1,39 +0,0 @@ -#nullable disable -namespace TestProject1.Models; - - -public interface IRunLog -{ - int? LogId { get; set; } - string UserId { get; set; } - string ActionModule { get; set; } - string ActionName { get; set; } - DateTime ActionTime { get; init; } - string ActionResult { get; set; } - string ActionMessage { get; set; } -} - -[LightTable(Name = "RUN_LOG")] -public class RunLog : IRunLog -{ - [LightColumn(Name = "LOG_ID", PrimaryKey = true)] - public int? LogId { get; set; } - - [LightColumn(Name = "USER_ID")] - public string UserId { get; set; } - - [LightColumn(Name = "ACTION_MODULE")] - public string ActionModule { get; set; } - - [LightColumn(Name = "ACTION_NAME")] - public string ActionName { get; set; } - - [LightColumn(Name = "ACTION_TIME")] - public DateTime ActionTime { get; init; } = DateTime.Now; - - [LightColumn(Name = "ACTION_RESULT")] - public string ActionResult { get; set; } - - [LightColumn(Name = "ACTION_MESSAGE")] - public string ActionMessage { get; set; } -} diff --git a/test/TestProject1/Models/SmsLog.cs b/test/TestProject1/Models/SmsLog.cs deleted file mode 100644 index abf228f2..00000000 --- a/test/TestProject1/Models/SmsLog.cs +++ /dev/null @@ -1,21 +0,0 @@ -namespace TestProject1.Models; - -[LightTable(Name = "SMS_LOG", DatabaseKey = "Cache")] -public class SmsLog -{ - [LightFlat] - public SmsReceive Recive { get; set; } = new(); - - [LightColumn(Name = "CREATE_TIME")] - public DateTime CreateTime { get; set; } = DateTime.Now; -} - -public class SmsReceive -{ - [LightColumn(Name = "CODE")] - public int Code { get; set; } = 100; - [LightColumn(Name = "MSG")] - public string? Msg { get; set; } = "测试"; - [LightColumn(Name = "UUID")] - public string? Uuid { get; set; } = Guid.NewGuid().ToString(); -} \ No newline at end of file diff --git a/test/TestProject1/Models/User.cs b/test/TestProject1/Models/User.cs deleted file mode 100644 index 0d8ad622..00000000 --- a/test/TestProject1/Models/User.cs +++ /dev/null @@ -1,67 +0,0 @@ -#nullable disable -namespace TestProject1.Models; - - - -[LightTable(Name = "USER")] -public class User -{ - [LightColumn(Name = "USER_ID", PrimaryKey = true)] - public string UserId { get; set; } - [LightColumn(Name = "USER_NAME")] - public string UserName { get; set; } - [LightColumn(Name = "PASSWORD")] - public string Password { get; set; } - [LightColumn(Name = "AGE")] - public int? Age { get; set; } - [LightColumn(Name = "SIGN")] - public string Sign { get; set; } - [LightColumn(Name = "LAST_LOGIN")] - public DateTime? LastLogin { get; set; } - - [LightColumn(Name = "IS_LOCK")] - public bool IsLock { get; set; } - - [LightNavigate(ManyToMany = typeof(UserRole), MainName = nameof(UserId), SubName = nameof(UserRole.UserId))] - public IEnumerable UserRoles { get; set; } - -} - - - -public class User2 -{ - [LightColumn(Name = "USER_ID", PrimaryKey = true)] - public string UserId { get; } - [LightColumn(Name = "USER_NAME")] - public string UserName { get; init; } -} -[LightTable(Name = "USER")] -public class UserFlat -{ - [LightColumn(Name = "USER_ID", PrimaryKey = true)] - public string UserId { get; set; } - [LightColumn(Name = "USER_NAME")] - public string UserName { get; set; } - [LightColumn(Name = "PASSWORD")] - public string Password { get; set; } - - [LightColumn(Name = "SIGN")] - public string Sign { get; set; } - [LightColumn(Name = "LAST_LOGIN")] - public DateTime LastLogin { get; set; } - - [LightNavigate(ManyToMany = typeof(UserRole), MainName = nameof(UserId), SubName = nameof(UserRole.UserId))] - public IEnumerable UserRoles { get; set; } - - [LightFlat] - public PrivateInfo? PriInfo { get; set; } -} - -public class PrivateInfo -{ - [LightColumn(Name = "AGE")] - public int? Age { get; set; } - [LightColumn(Name = "IS_LOCK")] - public bool IsLock { get; set; } -} diff --git a/test/TestProject1/Models/UserRole.cs b/test/TestProject1/Models/UserRole.cs deleted file mode 100644 index ab55ad43..00000000 --- a/test/TestProject1/Models/UserRole.cs +++ /dev/null @@ -1,18 +0,0 @@ -#nullable disable -namespace TestProject1.Models; - - -[LightTable(Name = "USER_ROLE")] -public class UserRole -{ - [LightColumn(Name = "USER_ID", PrimaryKey = true)] - public string UserId { get; set; } - [LightColumn(Name = "ROLE_ID", PrimaryKey = true)] - public string RoleId { get; set; } - - [LightNavigateAttribute(nameof(UserId), nameof(User.UserId))] - public User User { get; set; } - - [LightNavigateAttribute(nameof(RoleId), nameof(Role.RoleId))] - public Role Role { get; set; } -} diff --git a/test/TestProject1/Other.cs b/test/TestProject1/Other.cs deleted file mode 100644 index 17f41103..00000000 --- a/test/TestProject1/Other.cs +++ /dev/null @@ -1,36 +0,0 @@ -using System.Data.Common; -using System.Data.SQLite; -using System.Text; - -namespace TestProject1 -{ - [TestClass] - public class Other - { - [TestMethod] - public void M() - { - StringBuilder sb = new(); - sb.Append("Hello World!"); - sb.Insert(5, " Insert"); - } - - private DbConnection? connection; - - private DbConnection GetConnection() - { - if (Interlocked.CompareExchange(ref connection, connection, null) == null) - { - connection = new SQLiteConnection(); - } - return connection!; - } - - [TestMethod] - public void Get() - { - var c = GetConnection(); - var c2 = GetConnection(); - } - } -} diff --git a/test/TestProject1/ResultTest/MultiActionTest.cs b/test/TestProject1/ResultTest/MultiActionTest.cs deleted file mode 100644 index e24c6e85..00000000 --- a/test/TestProject1/ResultTest/MultiActionTest.cs +++ /dev/null @@ -1,22 +0,0 @@ -namespace TestProject1.ResultTest -{ - [TestClass] - public class MultiActionTest : TestBase - { - const string UID = "TEST_USER"; - [TestMethod] - public void InsertEntity() - { - int hour = DateTime.Now.Hour; - var u = Db.Select().First()!; - u.UserId = UID; - u.Age = hour; - Db.Insert(u).Execute(); - var iu = Db.Select().Where(u => u.UserId == UID).First(); - Assert.IsTrue(iu?.Age == hour); - Db.Delete(iu).Execute(); - var iu2 = Db.Select().Where(u => u.UserId == UID).First(); - Assert.IsTrue(iu2 is null); - } - } -} diff --git a/test/TestProject1/ResultTest/SelectResult.cs b/test/TestProject1/ResultTest/SelectResult.cs deleted file mode 100644 index 01f47bdd..00000000 --- a/test/TestProject1/ResultTest/SelectResult.cs +++ /dev/null @@ -1,45 +0,0 @@ -namespace TestProject1.ResultTest -{ - [TestClass] - public class SelectResult : TestBase - { - class UU - { - public string? UserName { get; set; } - } - [TestMethod] - public void SelectList() - { - var list = Db.Select() - .InnerJoin((u, ur) => u.UserId == ur.UserId) - .ToDynamicList(w => new { w.Tb1.UserName }); - foreach (var item in list) - { - Console.WriteLine(item.UserName); - } - } - - class PP : Power - { - [LightORM.LightColumn(Name = "ROLE_ID")] - public string? RoleId { get; set; } - } - [TestMethod] - public void SelectExt() - { - var list = Db.Select() - .InnerJoin((p, rp) => p.PowerId == rp.PowerId) - .AsTable((p, rp) => new - { - rp.RoleId, - p.PowerId, - p.PowerName - }).AsSubQuery() - .ToList(); - foreach (var item in list) - { - Console.WriteLine($"{item.RoleId}-{item.PowerId}-{item.PowerName}"); - } - } - } -} diff --git a/test/TestProject1/SqlFunctionTest/FormatStringTest.cs b/test/TestProject1/SqlFunctionTest/FormatStringTest.cs deleted file mode 100644 index 2475ee2a..00000000 --- a/test/TestProject1/SqlFunctionTest/FormatStringTest.cs +++ /dev/null @@ -1,30 +0,0 @@ -using System.Linq.Expressions; -using LightORM.Providers.Sqlite; - -namespace TestProject1.SqlFunctionTest; - -[TestClass] -public class FormatStringTest: TestBase -{ - [TestMethod] - public void InterpolationFormat() - { - var name = "test"; - var seq = 0; - Expression> exp = u => u.UserName == $"{name}{seq}"; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Where, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void InterpolationFormatOption() - { - Expression> exp = u => u.UserName == $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}"; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Where, ctx); - Console.WriteLine(result.SqlString); - } -} \ No newline at end of file diff --git a/test/TestProject1/SqlFunctionTest/SqlFunTest.cs b/test/TestProject1/SqlFunctionTest/SqlFunTest.cs deleted file mode 100644 index 512dd3ab..00000000 --- a/test/TestProject1/SqlFunctionTest/SqlFunTest.cs +++ /dev/null @@ -1,101 +0,0 @@ -using LightORM.Providers.Sqlite; -using System.Linq.Expressions; - -namespace TestProject1.SqlFunctionTest; - -[TestClass] -public class SqlFunTest : TestBase -{ - [TestMethod] - public void RowNumber() - { - // ROW_NUMBER() OVER( PARTITION BY `u`.`USER_NAME` ORDER BY `u`.`AGE` ) AS `RowNum` - Expression> exp = (u) => new - { - RowNum = WinFn.RowNumber().PartitionBy(u.UserName).OrderBy(u.Age).Value() - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void Lag() - { - // ( `u`.`LAST_LOGIN` - LAG(`u`.`LAST_LOGIN`) OVER( PARTITION BY `u`.`USER_NAME` ORDER BY `u`.`AGE` ) ) AS `DateDiff` - Expression> exp = (u) => new - { - DateDiff = u.LastLogin - WinFn.Lag(u.LastLogin).PartitionBy(u.UserName).OrderBy(u.Age).Value() - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void CaseWhen() - { - Expression> exp = u => new - { - Total = SqlFn.Count(SqlFn.Case().When(u.Age > 10).Then(u.Age).Else(0).End()) - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void Join() - { - Expression> exp = u => new - { - Result = SqlFn.Join(u.Age > 10 ? u.UserName : "").Separator("|").Distinct().OrderBy(u.UserId).Value() - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void Abs() - { - Expression> exp = u => new - { - Result = SqlFn.Abs(u.Age) - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void ConvertString() - { - Expression> exp = u => new - { - Result = u.LastLogin.Value.ToString("yyyy-MM-dd") - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } - - [TestMethod] - public void NullThenFunc() - { - Expression> exp = u => new - { - Result = SqlFn.NullThen(u.Age, 0) - }; - var ctx = new ResolveContext(CustomSqliteAdapter.TestInstance); - HandleExpressionParameters(ctx, exp); - var result = exp.Resolve(SqlResolveOptions.Select, ctx); - Console.WriteLine(result.SqlString); - } -} diff --git a/test/TestProject1/SqlTest/SelectResult.cs b/test/TestProject1/SqlTest/SelectResult.cs deleted file mode 100644 index 9af994d3..00000000 --- a/test/TestProject1/SqlTest/SelectResult.cs +++ /dev/null @@ -1,73 +0,0 @@ -namespace TestProject1.SqlTest; - -[TestClass] -public class SelectResult : TestBase -{ - [TestMethod] - public void ToListResult() - { - var list = Db.Select().ToList(); - foreach (var item in list) - { - Console.WriteLine(item.UserId); - if (item.UserId == "admin") - { - Assert.IsTrue(true); - } - } - } - - [TestMethod] - public void AnonymousResult() - { - var list = Db.Select().ToList(u => new { u.UserId, u.UserName }); - foreach (var item in list) - { - Console.WriteLine(item.UserId); - if (item.UserId == "admin") - { - Assert.IsTrue(true); - } - } - } - - class SimpleUser - { - public string? UserId { get; set; } - public string? UserName { get; set; } - } - [TestMethod] - public void AcceptAnonymousResult() - { - var list = Db.Select() - .AsTable(u => new { u.UserId, u.UserName }) - .ToList(); - foreach (var item in list) - { - Console.WriteLine(item.UserId); - if (item.UserId == "admin") - { - Assert.IsTrue(true); - } - } - } - class SimpleUser2 - { - public string? USER_ID { get; set; } - public string? USER_NAME { get; set; } - } - [TestMethod] - public void AcceptOtherTypeResult() - { - var list = Db.Select() - .ToList(); - foreach (var item in list) - { - Console.WriteLine(item.USER_ID); - if (item.USER_ID == "admin") - { - Assert.IsTrue(true); - } - } - } -} diff --git a/test/TestProject1/StringBuilderHelperTest.cs b/test/TestProject1/StringBuilderHelperTest.cs deleted file mode 100644 index ca575856..00000000 --- a/test/TestProject1/StringBuilderHelperTest.cs +++ /dev/null @@ -1,31 +0,0 @@ -using LightORM.Extension; -using System.Text; - -namespace TestProject1 -{ - [TestClass] - public class StringBuilderHelperTest - { - [TestMethod] - public void EndsWith() - { - var sb = new StringBuilder("Hello123212Owdssa"); - Assert.IsTrue(sb.EndsWith("wdssa")); - Assert.IsFalse(sb.EndsWith("wdss")); - } - - [TestMethod] - public void Trim() - { - var sb = new StringBuilder(" Hello123212Owdssa "); - var r1 = sb.Trim(); - Assert.IsTrue(r1 == "Hello123212Owdssa"); - sb.AppendLine(""); - Assert.IsTrue(sb.EndsWith("\r\n")); - r1 = sb.Trim(); - Assert.IsTrue(r1 == "Hello123212Owdssa"); - r1 = sb.Trim(' ', '\r', '\n'); - Assert.IsTrue(r1 == "Hello123212Owdssa"); - } - } -} diff --git a/test/TestProject1/TestBase.cs b/test/TestProject1/TestBase.cs deleted file mode 100644 index bca5d610..00000000 --- a/test/TestProject1/TestBase.cs +++ /dev/null @@ -1,40 +0,0 @@ -using LightORM.Implements; -using LightORM.Providers.Oracle.Extensions; -using LightORM.Providers.Sqlite.Extensions; -using System.Linq.Expressions; - -namespace TestProject1; - -public class TestBase -{ - protected static void HandleExpressionParameters(ResolveContext context, LambdaExpression lambda) - { - for (int i = 0; i < lambda.Parameters.Count; i++) - { - ParameterExpression? item = lambda.Parameters[i]; - context.HandleParameterExpression(item, i); - } - } - public IExpressionContext Db { get; } - internal ResolveContext ResolveCtx { get; } - protected ITableContext TableContext { get; } = new TestTableContext(); - public TestBase() - { - var path = Path.GetFullPath("../../../../../test.db"); - - ExpSqlFactory.Configuration(option => - { - //option.SetDatabase(DbBaseType.Sqlite, "DataSource=" + path, SQLiteFactory.Instance); - option.UseSqlite("DataSource=" + path); - option.UseOracle(o => - { - o.DbKey = "Oracle"; - o.MasterConnectionString = "User ID=IFSAPP;Password=IFSAPP;Data Source=RACE;"; - }); - option.SetTableContext(TableContext); - option.UseInterceptor(); - }); - Db = ExpSqlFactory.GetContext(); - ResolveCtx = ResolveContext.Create(DbBaseType.Oracle); - } -} diff --git a/test/TestProject1/TestInitContext.cs b/test/TestProject1/TestInitContext.cs deleted file mode 100644 index 498900a5..00000000 --- a/test/TestProject1/TestInitContext.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace TestProject1; - -public class TestInitContext : DbInitialContext -{ - public override void Initialized(IDbInitial db) - { - db.CreateTable(); - } -} diff --git a/test/TestProject1/TestProject1.csproj b/test/TestProject1/TestProject1.csproj deleted file mode 100644 index ac1b6b04..00000000 --- a/test/TestProject1/TestProject1.csproj +++ /dev/null @@ -1,38 +0,0 @@ - - - - net10.0 - enable - enable - false - true - - - - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - - - - - - - - - - - - - - diff --git a/test/TestProject1/TestTableContext.cs b/test/TestProject1/TestTableContext.cs deleted file mode 100644 index b15c4b89..00000000 --- a/test/TestProject1/TestTableContext.cs +++ /dev/null @@ -1,13 +0,0 @@ -namespace TestProject1; - -[LightORMTableContext] -internal partial class TestTableContext -{ - public void H(Type type) - { - if (type == typeof(int) || type.IsAssignableFrom(typeof(int))) - { - - } - } -} \ No newline at end of file diff --git a/test/TestProject1/TypeSetFlatTest.cs b/test/TestProject1/TypeSetFlatTest.cs deleted file mode 100644 index 77be8994..00000000 --- a/test/TestProject1/TypeSetFlatTest.cs +++ /dev/null @@ -1,64 +0,0 @@ -using LightORM.Interfaces.ExpSql; -using LightORM.Utils.Vistors; -using System.Linq.Expressions; - -namespace TestProject1; - -[TestClass] -public class TypeSetFlatTest : TestBase -{ - [TestMethod] - public void Flat() - { - Expression, bool>> exp = w => w.Tb1.Age > 10; - Expression> result = (u, p) => new { u }; - - var n = FlatTypeSet.Default.Flat(exp); - var nn = n.Resolve(SqlResolveOptions.Select, ResolveCtx); - } - - [TestMethod] - public void FlatNew() - { - Expression, object>> exp = w => new { w.Tb1.UserName, w.Tb2.Path }; - var n = FlatTypeSet.Default.Flat(exp); - Console.WriteLine(exp); - Console.WriteLine(n); - } - class IGr - { - public int? Age { get; set; } - public string? RoleId { get; set; } - } - [TestMethod] - public void FlatGroup() - { - Expression>, object>>? exp = w => new - { - w.Group.Age, - w.Group.RoleId, - R = w.Tables.Tb1.UserName, - T = w.Tables.Tb2.RoleId - }; - // (user, userrole, w) => new { w.Group, Total = w.Count(), Pass = w.Count(user.Age) } - var n = FlatTypeSet.Default.Flat(exp); - Console.WriteLine(exp); - Console.WriteLine(n); - } - - [TestMethod] - public void FlatGroup2() - { - Expression, object>>? exp = w => new - { - w.Group.Age, - w.Group.RoleId, - R = w.Tables.UserName, - }; - // (user, userrole, w) => new { w.Group, Total = w.Count(), Pass = w.Count(user.Age) } - var n = FlatTypeSet.Default.Flat(exp); - Console.WriteLine(exp); - Console.WriteLine(n); - } - -}